@afora/core 0.0.8 → 0.0.11

package/dist/core/tracing/tracing.d.ts

@@ -0,0 +1,72 @@
+import type { ExceptionLayers } from "../exception/enums/exception-layers.js";
+/**
+ * What a span carries: names and outcomes only, never an input, an argument,
+ * a response or any value of a record.
+ */
+export type TraceAttributes = Readonly<Record<string, string | number | boolean>>;
+/** How a span ended. */
+export type TraceStatus = "ok" | "error";
+/** A span afora started; it ends it once, with the attributes of the outcome. */
+export interface ITraceSpan {
+    end(status: TraceStatus, attributes: TraceAttributes): void;
+}
+/**
+ * What traces an application: a span per command operation, use case and
+ * repository call made through a use case. `@afora/otel` adapts an
+ * OpenTelemetry `Tracer` to it; `memoryTracer()` keeps the spans for tests.
+ */
+export interface ITracer {
+    /**
+     * Starts a span. `parent` is the span of the call that made this one (the
+     * command of a use case, the use case of a repository call), `undefined`
+     * for a call that starts a trace.
+     */
+    startSpan(name: string, attributes: TraceAttributes, parent: ITraceSpan | undefined): ITraceSpan;
+    /**
+     * Runs `run` with `span` as the current span, when the tracer has a notion
+     * of one (an OpenTelemetry context): what your code and the instrumented
+     * drivers start inside the call is nested in its span.
+     */
+    withSpan?<Result>(span: ITraceSpan, run: () => Result): Result;
+}
+/** Throws unless `value` can trace an application. */
+export declare function checkTracer(value: unknown): ITracer;
+/**
+ * Carries the tracer of an application, when it has a `trace`: on the
+ * application and on the use case classes it binds.
+ */
+export declare const ApplicationTracerKey: unique symbol;
+/**
+ * The tracer of a call: the one its scope carries, else the one of the
+ * application its class was bound by, else the started application's.
+ */
+export declare function resolveTracer(scoped: ITracer | undefined, owner: unknown): ITracer | undefined;
+/** Starts a span; a tracer that throws never breaks the call it traces. */
+export declare function startSpan(tracer: ITracer, name: string, attributes: TraceAttributes, parent: ITraceSpan | undefined): ITraceSpan | undefined;
+/** Runs `run` inside `span`, if the tracer can make it current. */
+export declare function runInSpan<Result>(tracer: ITracer, span: ITraceSpan, run: () => Result): Result;
+/** Ends a span that succeeded. */
+export declare function endSpan(span: ITraceSpan | undefined): void;
+/**
+ * Ends a span that failed, with the layer and name of the exception where it
+ * was first raised (`layer` and `UnexpectedError` for anything else thrown).
+ * Never its message, details or cause: they can hold values.
+ */
+export declare function failSpan(span: ITraceSpan | undefined, error: unknown, layer: ExceptionLayers): void;
+/** A span as `memoryTracer` keeps it. */
+export interface MemorySpan {
+    readonly name: string;
+    /** Those it started with, then those it ended with. */
+    readonly attributes: TraceAttributes;
+    readonly parent: MemorySpan | undefined;
+    /** `undefined` until it ends. */
+    readonly status: TraceStatus | undefined;
+}
+/** A tracer that keeps the spans, for tests. */
+export interface MemoryTracer extends ITracer {
+    /** Every span, in the order they started. */
+    readonly spans: readonly MemorySpan[];
+    clear(): void;
+}
+/** Keeps every span in `spans`, with its parent, for tests. */
+export declare function memoryTracer(): MemoryTracer;

package/dist/core/tracing/tracing.js

@@ -0,0 +1,101 @@
+import { startedApplication } from "../application/registry.js";
+import { Exception, UNEXPECTED_ERROR } from "../exception/exception.js";
+import { InvalidTraceDeclaration } from "./exceptions.js";
+export function checkTracer(value) {
+  if (typeof value !== "object" || value === null || typeof value.startSpan !== "function" || value.withSpan !== undefined && typeof value.withSpan !== "function") {
+    throw new InvalidTraceDeclaration({
+      source: "trace",
+      details: {
+        reason: "Expected `trace` to be a tracer: { startSpan(name, attributes, parent), withSpan? }."
+      }
+    });
+  }
+  return value;
+}
+export const ApplicationTracerKey = Symbol("afora.application.tracer");
+export function resolveTracer(scoped, owner) {
+  return scoped ?? owner?.[ApplicationTracerKey] ?? startedApplication()?.[ApplicationTracerKey];
+}
+export function startSpan(tracer, name, attributes, parent) {
+  try {
+    return tracer.startSpan(name, attributes, parent);
+  } catch {
+    return;
+  }
+}
+export function runInSpan(tracer, span, run) {
+  if (tracer.withSpan === undefined)
+    return run();
+  let ran = "no";
+  let result;
+  let thrown;
+  const once = () => {
+    try {
+      result = run();
+      ran = "returned";
+      return result;
+    } catch (error) {
+      ran = "threw";
+      thrown = error;
+      throw error;
+    }
+  };
+  try {
+    return tracer.withSpan(span, once);
+  } catch {
+    if (ran === "threw")
+      throw thrown;
+    return ran === "returned" ? result : run();
+  }
+}
+const OK = Object.freeze({ "afora.outcome": "ok" });
+export function endSpan(span) {
+  if (span === undefined)
+    return;
+  try {
+    span.end("ok", OK);
+  } catch {}
+}
+export function failSpan(span, error, layer) {
+  if (span === undefined)
+    return;
+  const origin = error instanceof Exception ? error.origin : undefined;
+  const name = origin?.name ?? UNEXPECTED_ERROR;
+  try {
+    span.end("error", {
+      "afora.outcome": "error",
+      "afora.exception.layer": origin?.layer ?? layer,
+      "afora.exception.name": name,
+      "afora.exception.unexpected": name === UNEXPECTED_ERROR
+    });
+  } catch {}
+}
+export function memoryTracer() {
+  const spans = [];
+  const recorded = new WeakMap;
+  return Object.freeze({
+    spans,
+    clear: () => {
+      spans.length = 0;
+    },
+    startSpan(name, attributes, parent) {
+      const span = {
+        name,
+        attributes: { ...attributes },
+        parent: parent === undefined ? undefined : recorded.get(parent),
+        status: undefined
+      };
+      spans.push(span);
+      const handle = {
+        end(status, ended) {
+          if (span.status !== undefined)
+            return;
+          span.status = status;
+          span.attributes = { ...span.attributes, ...ended };
+        }
+      };
+      recorded.set(handle, span);
+      return handle;
+    }
+  });
+}

package/dist/core/use-case/access.d.ts

@@ -0,0 +1,12 @@
+import type { AnyBlueprint } from "../blueprint/types/blueprint.interface.js";
+import type { AccessDeclaration } from "./types/access.interface.js";
+/** Whether `access` lets anyone in. */
+export declare function isPublicAccess(access: AccessDeclaration): access is {
+    readonly public: true;
+};
+/**
+ * The frozen declaration of `access` for a use case whose input is
+ * `blueprint`, or the reason it is not valid. The keys of `context` are
+ * checked where the context is known: when the use case becomes an operation.
+ */
+export declare function accessDeclarationOf(access: unknown, blueprint: AnyBlueprint): AccessDeclaration | string;

package/dist/core/use-case/access.js

@@ -0,0 +1,56 @@
+import { isScalarKey } from "./route.js";
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+const ACCESS_KEYS = ["public", "scopes", "owner", "context"];
+const PRINCIPAL_VALUE = /^(subject|scopes|claims\.[^.]+)$/;
+export function isPublicAccess(access) {
+  return access.public === true;
+}
+export function accessDeclarationOf(access, blueprint) {
+  if (!isObject(access)) {
+    return "Expected access to be { public: true } or { scopes?, owner?, context? }.";
+  }
+  for (const key of Object.keys(access)) {
+    if (!ACCESS_KEYS.includes(key))
+      return `access has no option "${key}".`;
+  }
+  const { scopes, owner, context } = access;
+  if (access.public !== undefined && typeof access.public !== "boolean") {
+    return "Expected access.public to be a boolean.";
+  }
+  if (access.public === true) {
+    if (Object.keys(access).length > 1) {
+      return "access.public leaves no room for scopes, owner or context: anyone may call.";
+    }
+    return Object.freeze({ public: true });
+  }
+  if (scopes !== undefined) {
+    if (!Array.isArray(scopes) || scopes.some((scope) => typeof scope !== "string" || scope === "") || new Set(scopes).size !== scopes.length) {
+      return "Expected access.scopes to be distinct, non-empty strings.";
+    }
+  }
+  if (owner !== undefined) {
+    if (!isObject(owner) || Object.keys(owner).some((key) => key !== "input" && key !== "claim") || typeof owner.input !== "string" || owner.claim !== undefined && (typeof owner.claim !== "string" || owner.claim === "")) {
+      return "Expected access.owner to be { input, claim? }.";
+    }
+    if (!isScalarKey(blueprint, owner.input)) {
+      return `access.owner compares "${owner.input}", which is not a scalar key of the input.`;
+    }
+  }
+  if (context !== undefined) {
+    if (!isObject(context)) {
+      return "Expected access.context to map context keys to values of the caller.";
+    }
+    for (const [key, value] of Object.entries(context)) {
+      if (typeof value !== "string" || !PRINCIPAL_VALUE.test(value)) {
+        return `Expected access.context["${key}"] to be "subject", "scopes" or "claims.<name>".`;
+      }
+    }
+  }
+  return Object.freeze({
+    ...scopes === undefined ? {} : { scopes: Object.freeze([...scopes]) },
+    ...owner === undefined ? {} : { owner: Object.freeze({ ...owner }) },
+    ...context === undefined ? {} : { context: Object.freeze({ ...context }) }
+  });
+}

package/dist/core/use-case/decorators.d.ts

@@ -0,0 +1,40 @@
+import type { AccessDeclaration } from "./types/access.interface.js";
+import type { RouteSettings } from "./types/route.interface.js";
+/** What a decorator of this module is given besides the class: nothing it reads. */
+type ClassContext = {
+    readonly kind: string;
+};
+/** A class decorator for use cases, in the standard form and in the legacy one of TypeScript. */
+export type UseCaseDecorator = <UseCase extends abstract new (...args: any[]) => unknown>(value: UseCase, context?: ClassContext) => void;
+/**
+ * Says where a use case is served over HTTP, on the class itself:
+ *
+ * ```ts
+ * @Route("GET", "/posts/{slug}", { query: ["page"], cookie: { session: "sid" } })
+ * class ListPosts extends useCaseOf({ name: "ListPosts", blueprint, response }) {}
+ * ```
+ *
+ * The same as the `route` setting of `useCaseOf` (see `RouteDeclaration`), so
+ * `describe()`, the sinks and `afora.json` see one declaration. It names no
+ * server: the sink of an output does. Throws `InvalidUseCaseDeclaration` on
+ * a class that is not a use case, on one that already has another route
+ * (the same one again is accepted), and for a route that does not fit the
+ * input of the use case.
+ */
+export declare function Route(method: RouteSettings["method"], path?: string, options?: Omit<RouteSettings, "method" | "path">): UseCaseDecorator;
+export declare function Route(method: RouteSettings["method"], options?: Omit<RouteSettings, "method" | "path">): UseCaseDecorator;
+/**
+ * Says who may call a use case, on the class itself:
+ *
+ * ```ts
+ * @Access({ scopes: ["posts:write"], context: { userId: "subject" } })
+ * class PublishPost extends useCaseOf({ name: "PublishPost", blueprint, response, context }) {}
+ * ```
+ *
+ * The same as the `access` setting of `useCaseOf` (see `AccessDeclaration`).
+ * Throws `InvalidUseCaseDeclaration` on a class that is not a use case, on
+ * one that already declares another access (the same one again is accepted),
+ * and for a declaration that does not fit the input of the use case.
+ */
+export declare function Access(access: AccessDeclaration): UseCaseDecorator;
+export {};

package/dist/core/use-case/decorators.js

@@ -0,0 +1,65 @@
+import { Kind } from "../symbols/kind.js";
+import { accessDeclarationOf } from "./access.js";
+import { routeDeclarationOf } from "./route.js";
+import { InvalidUseCaseDeclaration } from "./use-case.js";
+function sameData(a, b) {
+  if (a === b)
+    return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null || Array.isArray(a) !== Array.isArray(b)) {
+    return false;
+  }
+  const left = Object.keys(a);
+  return left.length === Object.keys(b).length && left.every((key) => Object.hasOwn(b, key) && sameData(a[key], b[key]));
+}
+function decoratedUseCase(value, decorator) {
+  if (typeof value !== "function" || value[Kind] !== "use-case") {
+    throw new InvalidUseCaseDeclaration({
+      source: decorator,
+      details: {
+        reason: `${decorator} decorates a class that extends useCaseOf(...).`
+      }
+    });
+  }
+  return value;
+}
+export function Route(method, pathOrOptions, options) {
+  const settings = typeof pathOrOptions === "string" ? { ...options, method, path: pathOrOptions } : { ...pathOrOptions, method };
+  return (value) => {
+    const UseCase = decoratedUseCase(value, "@Route");
+    const invalid = (reason) => {
+      throw new InvalidUseCaseDeclaration({
+        source: UseCase.useCaseName,
+        details: { reason }
+      });
+    };
+    const declared = routeDeclarationOf(settings, UseCase.blueprint, UseCase.response);
+    if (typeof declared === "string")
+      return invalid(declared);
+    if (UseCase.route !== undefined) {
+      if (sameData(UseCase.route, declared))
+        return;
+      invalid("The use case already has another route: declare it once, with the route setting or with @Route.");
+    }
+    Object.defineProperty(UseCase, "route", { value: declared });
+  };
+}
+export function Access(access) {
+  return (value) => {
+    const UseCase = decoratedUseCase(value, "@Access");
+    const invalid = (reason) => {
+      throw new InvalidUseCaseDeclaration({
+        source: UseCase.useCaseName,
+        details: { reason }
+      });
+    };
+    const declared = accessDeclarationOf(access, UseCase.blueprint);
+    if (typeof declared === "string")
+      return invalid(declared);
+    if (UseCase.access !== undefined) {
+      if (sameData(UseCase.access, declared))
+        return;
+      invalid("The use case already declares another access: declare it once, with the access setting or with @Access.");
+    }
+    Object.defineProperty(UseCase, "access", { value: declared });
+  };
+}

package/dist/core/use-case/exceptions.d.ts

@@ -1,12 +1,16 @@
+import type { Issue } from "../parse/types/parse.interface.js";
 /**
  * A step of a use case is invalid: at declaration (`useCaseOf({ steps })`),
  * or while the steps run (a `change` or `invoke` on something that is not a
- * record or has no such member). `details.index` is the position of the step.
+ * record or has no such member, or `args` that a `run`'s `params` reject).
+ * `details.index` is the position of the step.
  */
 export declare const InvalidUseCaseStep: import("../../index.js").DeclaredExceptionClass<{
     readonly index: number;
     readonly reason: string;
     readonly code?: string;
+    /** The issues of the `args` a `run` gave its `params` (`code: "invalid_args"`). */
+    readonly issues?: readonly Issue[];
 }>;
 /**
  * `useCasePluginOf` or `useCaseCatalogOf` was given what cannot be a plugin

package/dist/core/use-case/exceptions.js

@@ -0,0 +1,48 @@
+import { ExceptionLayers } from "../exception/enums/exception-layers.js";
+import { exceptionOf } from "../exception/exception.js";
+export const InvalidUseCaseStep = exceptionOf({
+  layer: ExceptionLayers.UseCase,
+  name: "InvalidUseCaseStep",
+  message: ({
+    index,
+    reason
+  }) => `Invalid step ${index}: ${reason}`
+});
+export const InvalidUseCasePlugin = exceptionOf({
+  layer: ExceptionLayers.UseCase,
+  name: "InvalidUseCasePlugin",
+  message: ({ reason }, source) => `Invalid use case plugin "${source}": ${reason}.`
+});
+export const UnknownUseCasePlugin = exceptionOf({
+  layer: ExceptionLayers.UseCase,
+  name: "UnknownUseCasePlugin",
+  message: ({ name }) => `No use case plugin "${name}" in the catalog.`
+});
+export const IncompatibleUseCasePlugin = exceptionOf({
+  layer: ExceptionLayers.UseCase,
+  name: "IncompatibleUseCasePlugin",
+  message: ({ reason }, source) => `Incompatible use case plugin "${source}": ${reason}.`
+});
+export const UseCaseUnavailable = exceptionOf({
+  layer: ExceptionLayers.UseCase,
+  name: "UseCaseUnavailable",
+  message: ({
+    repository,
+    reason
+  }, source) => `The use case "${source}" is not available for "${repository}": ${reason}.`
+});
+export const UseCaseEntityNotFound = exceptionOf({
+  layer: ExceptionLayers.UseCase,
+  name: "UseCaseEntityNotFound",
+  message: "The entity was not found."
+});
+export const UseCaseEntityConflict = exceptionOf({
+  layer: ExceptionLayers.UseCase,
+  name: "UseCaseEntityConflict",
+  message: "The entity already exists."
+});
+export const UseCaseInvalidCredentials = exceptionOf({
+  layer: ExceptionLayers.UseCase,
+  name: "UseCaseInvalidCredentials",
+  message: "Invalid credentials."
+});

package/dist/core/use-case/plugin-catalog.js

@@ -0,0 +1,68 @@
+import { isVersion, satisfies } from "../record/plugin.js";
+import { Kind } from "../symbols/kind.js";
+import {
+  IncompatibleUseCasePlugin,
+  InvalidUseCasePlugin,
+  UnknownUseCasePlugin
+} from "./exceptions.js";
+import { isUseCasePlugin } from "./plugin.js";
+export function isUseCaseCatalog(value) {
+  return typeof value === "object" && value !== null && value[Kind] === "use-case-catalog";
+}
+export function useCaseCatalogOf(...plugins) {
+  const byName = {};
+  const context = {};
+  for (const plugin of plugins) {
+    if (!isUseCasePlugin(plugin)) {
+      throw new InvalidUseCasePlugin({
+        source: "catalog",
+        details: {
+          reason: "a catalog takes plugins made by `useCasePluginOf`"
+        }
+      });
+    }
+    if (Object.hasOwn(byName, plugin.name)) {
+      throw new InvalidUseCasePlugin({
+        source: plugin.name,
+        details: { reason: "the catalog has another plugin with its name" }
+      });
+    }
+    byName[plugin.name] = plugin;
+    context[plugin.name] = plugin.make;
+  }
+  const find = (name) => {
+    const plugin = Object.hasOwn(byName, name) ? byName[name] : undefined;
+    if (!plugin) {
+      throw new UnknownUseCasePlugin({ source: "catalog", details: { name } });
+    }
+    return plugin;
+  };
+  return Object.freeze({
+    [Kind]: "use-case-catalog",
+    plugins: Object.freeze(byName),
+    list: Object.freeze([...plugins]),
+    context: Object.freeze(context),
+    resolve(reference) {
+      const at = typeof reference === "string" ? reference.lastIndexOf("@") : -1;
+      if (at <= 0)
+        return find(String(reference));
+      const plugin = find(reference.slice(0, at));
+      const version = reference.slice(at + 1);
+      if (!isVersion(version)) {
+        throw new IncompatibleUseCasePlugin({
+          source: plugin.name,
+          details: { reason: `"${version}" is not a semantic version` }
+        });
+      }
+      if (!satisfies(plugin.version, version)) {
+        throw new IncompatibleUseCasePlugin({
+          source: plugin.name,
+          details: {
+            reason: `version ${plugin.version} does not satisfy ${version}`
+          }
+        });
+      }
+      return plugin;
+    }
+  });
+}

package/dist/core/use-case/plugin.js

@@ -0,0 +1,133 @@
+import { hasPlugin, isVersion } from "../record/plugin.js";
+import { isRepository } from "../repository/repository.js";
+import { inspectRepository } from "../repository/state.js";
+import { Kind } from "../symbols/kind.js";
+import { InvalidUseCasePlugin, UseCaseUnavailable } from "./exceptions.js";
+import { isPlain } from "./steps/references.js";
+import { useCaseTargetOf } from "./target.js";
+import { useCaseOf } from "./use-case.js";
+const UseCaseOrigin = Symbol("useCaseOrigin");
+const NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const identities = new WeakMap;
+let nextIdentity = 0;
+function keyOf(value) {
+  if (typeof value === "function" || typeof value === "object" && value) {
+    if (Array.isArray(value))
+      return `[${value.map(keyOf).join(",")}]`;
+    if (isPlain(value)) {
+      return `{${Object.keys(value).sort().filter((key) => value[key] !== undefined).map((key) => `${JSON.stringify(key)}:${keyOf(value[key])}`).join(",")}}`;
+    }
+    let identity = identities.get(value);
+    if (identity === undefined) {
+      identity = nextIdentity++;
+      identities.set(value, identity);
+    }
+    return `#${identity}`;
+  }
+  return value === undefined ? "undefined" : JSON.stringify(value);
+}
+export function isUseCasePlugin(value) {
+  return typeof value === "object" && value !== null && value[Kind] === "use-case-plugin";
+}
+export function useCaseOriginOf(UseCase) {
+  return typeof UseCase === "function" ? UseCase[UseCaseOrigin] : undefined;
+}
+export function useCasePluginOf(name, settings) {
+  const source = typeof name === "string" ? name : "useCasePluginOf";
+  const invalid = (reason) => {
+    throw new InvalidUseCasePlugin({ source, details: { reason } });
+  };
+  if (typeof name !== "string" || !NAME.test(name)) {
+    invalid("its name must be an identifier");
+  }
+  if (!isPlain(settings) || typeof settings.compile !== "function") {
+    invalid("it needs a compile function");
+  }
+  const { version = "1.0.0", description, compile } = settings;
+  if (!isVersion(version)) {
+    invalid(`"${String(version)}" is not a semantic version`);
+  }
+  if (description !== undefined && typeof description !== "string") {
+    invalid("its description must be a string");
+  }
+  const names = (list, what) => {
+    if (list === undefined)
+      return Object.freeze([]);
+    if (!Array.isArray(list) || list.some((item) => typeof item !== "string" || item === "")) {
+      invalid(`requires.${what} must be a list of names`);
+    }
+    return Object.freeze([...new Set(list)]);
+  };
+  if (settings.requires !== undefined && !isPlain(settings.requires)) {
+    invalid("requires must be an object of actions and plugins");
+  }
+  const requires = Object.freeze({
+    actions: names(settings.requires?.actions, "actions"),
+    plugins: names(settings.requires?.plugins, "plugins")
+  });
+  const made = new WeakMap;
+  const make = (repository, given) => {
+    if (!isRepository(repository)) {
+      return invalid("it makes a use case for a repository of repositoryOf");
+    }
+    if (given !== undefined && !isPlain(given)) {
+      return invalid("its options must be a plain object");
+    }
+    const options = Object.freeze({ ...given });
+    const info = inspectRepository(repository);
+    let classes = made.get(info.state);
+    if (!classes) {
+      classes = new Map;
+      made.set(info.state, classes);
+    }
+    const key = keyOf(options);
+    const known = classes.get(key);
+    if (known)
+      return known;
+    const target = useCaseTargetOf(repository, name);
+    const missing = {
+      actions: requires.actions.filter((action) => !info.actions.includes(action)),
+      plugins: requires.plugins.filter((plugin) => !hasPlugin(info.entity, plugin))
+    };
+    if (missing.actions.length > 0 || missing.plugins.length > 0) {
+      const quoted = (list) => list.map((item) => `"${item}"`).join(", ");
+      throw new UseCaseUnavailable({
+        source: name,
+        details: {
+          repository: target.repositoryName,
+          reason: [
+            missing.actions.length > 0 ? `the repository lacks the action ${quoted(missing.actions)}` : undefined,
+            missing.plugins.length > 0 ? `the entity lacks the plugin ${quoted(missing.plugins)}` : undefined
+          ].filter(Boolean).join(" and "),
+          missing
+        }
+      });
+    }
+    const UseCase = useCaseOf(compile(target, options));
+    Object.defineProperty(UseCase, UseCaseOrigin, {
+      value: Object.freeze({
+        plugin,
+        repository,
+        options
+      })
+    });
+    classes.set(key, UseCase);
+    return UseCase;
+  };
+  const plugin = Object.freeze({
+    [Kind]: "use-case-plugin",
+    name,
+    version,
+    ...description === undefined ? {} : { description },
+    requires,
+    make,
+    toJSON: () => ({
+      kind: "use-case-plugin",
+      name,
+      version,
+      ...description === undefined ? {} : { description },
+      requires
+    })
+  });
+  return plugin;
+}

package/dist/core/use-case/route.d.ts

@@ -0,0 +1,18 @@
+import type { AnyBlueprint } from "../blueprint/types/blueprint.interface.js";
+import type { OpenAPISchema } from "../openapi/types/openapi.interface.js";
+import type { RouteDeclaration } from "./types/route.interface.js";
+/** A header name (an HTTP token), which a cookie name is too. */
+export declare const HEADER_NAME: RegExp;
+/** A path such as `/entries/{slug}`: `{name}` only as a whole segment, no `:`, `*`, query or spaces. */
+export declare function isRoutePath(value: unknown, parameters?: boolean): value is string;
+/** The names of the `{name}` segments of `path`, in order. */
+export declare function parametersOfPath(path: string): string[];
+/** Whether a JSON Schema describes a value that is neither an object nor a list. */
+export declare function isScalarSchema(schema: OpenAPISchema): boolean;
+/** Whether `name` is a key of `blueprint` that is a scalar property (no object, no list). */
+export declare function isScalarKey(blueprint: AnyBlueprint, name: string): boolean;
+/**
+ * The frozen, normalized declaration of `route` for a use case whose input is
+ * `blueprint` (the method in lower case), or the reason it is not valid.
+ */
+export declare function routeDeclarationOf(route: unknown, blueprint: AnyBlueprint, response: AnyBlueprint): RouteDeclaration | string;