@afora/core 0.0.8 → 0.0.11

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

@@ -0,0 +1,493 @@
+import { isBlueprint } from "../blueprint/is-blueprint.js";
+import { isBlueprintList } from "../blueprint/list.js";
+import { isRecordClass, recordFieldOf } from "../blueprint/record-field.js";
+import { isBlueprintVariant, variantOfValue } from "../blueprint/variant.js";
+import { isEntity } from "../entity/entity.js";
+import {
+  isEnvironment
+} from "../environment/environment.js";
+import { ExceptionLayers } from "../exception/enums/exception-layers.js";
+import {
+  Exception,
+  exceptionOf,
+  isDeclaredException
+} from "../exception/exception.js";
+import { guard } from "../exception/guard.js";
+import {
+  clock,
+  elapsed,
+  isLogger,
+  isLoggerDeclaration,
+  logFailure,
+  resolveLogger,
+  silentLogger,
+  writeLog
+} from "../logger/logger.js";
+import { recordNameOf } from "../record/name.js";
+import { AbstractRepository, isRepository } from "../repository/repository.js";
+import { Kind } from "../symbols/kind.js";
+import {
+  endSpan,
+  failSpan,
+  resolveTracer,
+  runInSpan,
+  startSpan
+} from "../tracing/tracing.js";
+import { accessDeclarationOf } from "./access.js";
+import { routeDeclarationOf } from "./route.js";
+import { ScopeKey } from "./scope.js";
+import { freezeData } from "./steps/references.js";
+import { executeSteps } from "./steps/run.js";
+import { validateSteps } from "./steps/validate.js";
+export const InvalidUseCaseDeclaration = exceptionOf({
+  layer: ExceptionLayers.UseCase,
+  name: "InvalidUseCaseDeclaration",
+  message: ({ reason }) => reason
+});
+export const UseCaseAlreadyExecuted = exceptionOf({
+  layer: ExceptionLayers.UseCase,
+  name: "UseCaseAlreadyExecuted",
+  message: "A UseCase instance can execute only once."
+});
+export const InvalidUseCaseDependencies = exceptionOf({
+  layer: ExceptionLayers.UseCase,
+  name: "InvalidUseCaseDependencies",
+  message: "Dependency overrides must contain only declared names: functions for use cases, objects of methods for repositories, and valid variables for environments."
+});
+function loggerOfCall(state) {
+  return resolveLogger(state.scope?.logger, state.owner);
+}
+const states = new WeakMap;
+function issuesSummaryOf(issues) {
+  const [first] = issues;
+  if (first === undefined)
+    return ".";
+  const path = first.path.join(".");
+  const more = issues.length > 1 ? ` (and ${issues.length - 1} more)` : "";
+  return `: ${path === "" ? "" : `"${path}" `}${first.message}${more}.`;
+}
+function invalidValue(issues, source, phase) {
+  throw new Exception({
+    layer: ExceptionLayers.UseCase,
+    name: phase === "input" ? "InvalidUseCaseInput" : phase === "context" ? "InvalidUseCaseContext" : "InvalidUseCaseResponse",
+    source,
+    message: `Invalid UseCase ${phase}${issuesSummaryOf(issues)}`,
+    details: { issues },
+    cause: issues.find((issue) => issue.cause)?.cause
+  });
+}
+function collectEvents(blueprint, value, events) {
+  const visited = new WeakSet;
+  const visit = (field, current) => {
+    if (typeof current !== "object" || current === null || visited.has(current))
+      return;
+    visited.add(current);
+    if (isEntity(current))
+      events.push(...current.pullEvents());
+    if (isBlueprintList(field)) {
+      for (const item of current)
+        visit(field.item, item);
+      return;
+    }
+    const shape = isBlueprint(field) ? field : isBlueprintVariant(field) ? isRecordClass(current.constructor) ? current.constructor.blueprint : variantOfValue(field, current) : recordFieldOf(field)?.record.blueprint;
+    if (!shape)
+      return;
+    for (const [key, child] of Object.entries(shape.properties)) {
+      visit(child, current[key]);
+    }
+  };
+  visit(blueprint, value);
+}
+function pullEntities(value, Entity, events) {
+  for (const item of Array.isArray(value) ? value : [value]) {
+    if (isEntity(item) && item instanceof Entity) {
+      events.push(...item.pullEvents());
+    }
+  }
+}
+function methodNamesOf(repository) {
+  const names = new Set;
+  for (let current = repository;current !== null && current !== AbstractRepository.prototype && current !== Object.prototype; current = Object.getPrototypeOf(current)) {
+    for (const name of Object.getOwnPropertyNames(current)) {
+      const descriptor = Object.getOwnPropertyDescriptor(current, name);
+      if (name !== "constructor" && typeof descriptor?.value === "function") {
+        names.add(name);
+      }
+    }
+  }
+  return [...names];
+}
+function traceUseCase(tracer, state, source) {
+  const span = startSpan(tracer, `use-case ${source}`, { "afora.use_case": source }, state.scope?.span);
+  if (span === undefined)
+    return;
+  state.tracer = tracer;
+  state.span = span;
+  state.childScope = {
+    ...state.scope,
+    providers: state.scope?.providers ?? new Map,
+    tracer,
+    span
+  };
+  return span;
+}
+function untrace(state) {
+  state.tracer = undefined;
+  state.span = undefined;
+  state.childScope = undefined;
+}
+async function tracedRepositoryCall(tracer, parent, repository, method, useCase, run) {
+  const span = startSpan(tracer, `repository ${repository}.${method}`, {
+    "afora.repository": repository,
+    "afora.method": method,
+    "afora.use_case": useCase
+  }, parent);
+  try {
+    const result = await (span === undefined ? run(undefined) : runInSpan(tracer, span, () => run(span)));
+    endSpan(span);
+    return result;
+  } catch (error) {
+    failSpan(span, error, ExceptionLayers.Repository);
+    throw error;
+  }
+}
+function bindRepository(repository, overrides, state, source) {
+  const Entity = repository.entity;
+  const repositoryName = recordNameOf(Entity);
+  const bound = Object.create(null);
+  const view = new Proxy(Object.create(repository), {
+    get: (_target, key, receiver) => {
+      if (typeof key === "string" && Object.hasOwn(bound, key)) {
+        return bound[key];
+      }
+      if (key === ScopeKey)
+        return state.scope;
+      const value = Reflect.get(repository, key, receiver);
+      return key === "provider" && state.scope ? state.scope.providers.get(value) ?? value : value;
+    },
+    set: (_target, key, value) => Reflect.set(repository, key, value),
+    defineProperty: (_target, key, descriptor) => Reflect.defineProperty(repository, key, descriptor),
+    deleteProperty: (_target, key) => Reflect.deleteProperty(repository, key)
+  });
+  const calls = Object.create(null);
+  const nestedView = (span) => new Proxy(view, {
+    get: (_target, key, receiver) => typeof key === "string" && Object.hasOwn(calls, key) ? (...args) => calls[key](args, span) : Reflect.get(view, key, receiver)
+  });
+  const bind = (target, name, receiver) => {
+    const method = target[name];
+    const call = async (args, parent) => {
+      if (!state.active)
+        throw new InvalidUseCaseDependencies({ source });
+      const started = clock();
+      const result = parent === undefined ? await method.apply(receiver, args) : await tracedRepositoryCall(state.tracer, parent, repositoryName, name, source, (span) => method.apply(span !== undefined && receiver === view ? nestedView(span) : receiver, args));
+      writeLog(loggerOfCall(state), "debug", "repository", {
+        repository: repositoryName,
+        method: name,
+        useCase: source,
+        ms: elapsed(started)
+      });
+      for (const arg of args)
+        pullEntities(arg, Entity, state.events);
+      pullEntities(result, Entity, state.events);
+      return result;
+    };
+    calls[name] = call;
+    bound[name] = (...args) => call(args, state.span);
+  };
+  for (const name of methodNamesOf(repository))
+    bind(repository, name, view);
+  if (overrides) {
+    for (const name of new Set([
+      ...methodNamesOf(repository),
+      ...methodNamesOf(overrides)
+    ])) {
+      if (typeof overrides[name] === "function") {
+        bind(overrides, name, overrides);
+      }
+    }
+  }
+  bound.entity = Entity;
+  bound.actions = repository.actions;
+  return Object.freeze(bound);
+}
+function narrowedContext(Child, parent) {
+  if (!Child.context || parent === undefined)
+    return;
+  const picked = {};
+  for (const key of Object.keys(Child.context.properties)) {
+    if (Object.hasOwn(parent, key)) {
+      picked[key] = parent[key];
+    }
+  }
+  return picked;
+}
+function isOverrideOf(dependency, value) {
+  if (isLoggerDeclaration(dependency))
+    return isLogger(value);
+  if (isRepository(dependency) || isEnvironment(dependency)) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  return typeof value === "function";
+}
+
+export class AbstractUseCase {
+  input;
+  constructor(input, ...args) {
+    const declaration = this.constructor;
+    const source = declaration.useCaseName;
+    const parsed = declaration.blueprint.safeParse(input);
+    if (parsed.issues)
+      invalidValue(parsed.issues, source, "input");
+    this.input = parsed.value;
+    const options = args[0];
+    const scope = options?.[ScopeKey];
+    let context;
+    if (declaration.context) {
+      const checked = declaration.context.safeParse(options?.context);
+      if (checked.issues)
+        invalidValue(checked.issues, source, "context");
+      context = Object.freeze(checked.value);
+    }
+    Object.defineProperty(this, "context", {
+      value: context,
+      enumerable: true
+    });
+    Object.defineProperty(this, "input", {
+      writable: false,
+      configurable: false
+    });
+    const implementation = this.execute;
+    if (typeof implementation !== "function") {
+      throw new InvalidUseCaseDeclaration({
+        source,
+        details: { reason: "Implement execute as a prototype method." }
+      });
+    }
+    const state = {
+      context,
+      scope,
+      started: false,
+      active: false,
+      events: [],
+      dependencies: Object.create(null),
+      owner: this.constructor
+    };
+    states.set(this, state);
+    for (const [key, dependency] of Object.entries(declaration.dependencies)) {
+      if (isRepository(dependency)) {
+        state.dependencies[key] = bindRepository(dependency, undefined, state, source);
+        continue;
+      }
+      if (isLoggerDeclaration(dependency)) {
+        Object.defineProperty(state.dependencies, key, {
+          get: () => loggerOfCall(state) ?? silentLogger,
+          enumerable: true
+        });
+        continue;
+      }
+      if (isEnvironment(dependency)) {
+        Object.defineProperty(state.dependencies, key, {
+          get: () => state.scope?.environments?.get(dependency) ?? dependency.load(),
+          enumerable: true
+        });
+        continue;
+      }
+      const Child = dependency;
+      state.dependencies[key] = async (value) => {
+        if (!state.active)
+          throw new InvalidUseCaseDependencies({ source });
+        const child = new Child(value, {
+          context: narrowedContext(Child, state.context),
+          [ScopeKey]: state.childScope ?? state.scope
+        });
+        try {
+          return await child.execute();
+        } finally {
+          state.events.push(...child.pullEvents());
+        }
+      };
+    }
+    Object.freeze(state.dependencies);
+    Object.defineProperty(this, "execute", {
+      value: async (overrides = {}) => {
+        if (state.started)
+          throw new UseCaseAlreadyExecuted({ source });
+        state.started = true;
+        const tracer = resolveTracer(state.scope?.tracer, state.owner);
+        const span = tracer === undefined ? undefined : traceUseCase(tracer, state, source);
+        try {
+          if (typeof overrides !== "object" || overrides === null || Array.isArray(overrides) || Reflect.ownKeys(overrides).some((key) => typeof key !== "string" || !Object.hasOwn(declaration.dependencies, key) || !isOverrideOf(declaration.dependencies[key], overrides[key]))) {
+            throw new InvalidUseCaseDependencies({ source });
+          }
+          const replaced = overrides;
+          const dependencies = {};
+          for (const key of Object.keys(declaration.dependencies)) {
+            if (!Object.hasOwn(replaced, key)) {
+              dependencies[key] = state.dependencies[key];
+            }
+          }
+          for (const [key, substitute] of Object.entries(replaced)) {
+            const dependency = declaration.dependencies[key];
+            if (isRepository(dependency)) {
+              dependencies[key] = bindRepository(dependency, substitute, state, source);
+              continue;
+            }
+            if (isLoggerDeclaration(dependency)) {
+              dependencies[key] = substitute;
+              continue;
+            }
+            if (isEnvironment(dependency)) {
+              const parsed = dependency.blueprint.safeParse(substitute);
+              if (parsed.issues)
+                throw new InvalidUseCaseDependencies({ source });
+              dependencies[key] = Object.freeze(parsed.value);
+              continue;
+            }
+            const Child = dependency;
+            dependencies[key] = async (value) => {
+              if (!state.active)
+                throw new InvalidUseCaseDependencies({ source });
+              const childSource = Child.useCaseName;
+              const input = Child.blueprint.safeParse(value);
+              if (input.issues)
+                invalidValue(input.issues, childSource, "input");
+              const output = Child.response.safeParse(await guard({ layer: ExceptionLayers.UseCase, source: childSource }, () => substitute(input.value)));
+              if (output.issues)
+                invalidValue(output.issues, childSource, "response");
+              collectEvents(Child.response, output.value, state.events);
+              return output.value;
+            };
+          }
+          state.resolved = Object.freeze(dependencies);
+        } catch (error) {
+          if (tracer !== undefined) {
+            failSpan(span, error, ExceptionLayers.UseCase);
+            untrace(state);
+          }
+          throw error;
+        }
+        state.active = true;
+        const started = clock();
+        try {
+          const result = await guard({ layer: ExceptionLayers.UseCase, source }, () => span === undefined ? implementation.call(this, state.resolved) : runInSpan(tracer, span, () => implementation.call(this, state.resolved)));
+          const parsed = declaration.response.safeParse(result);
+          if (parsed.issues)
+            invalidValue(parsed.issues, source, "response");
+          collectEvents(declaration.response, parsed.value, state.events);
+          writeLog(loggerOfCall(state), "debug", "use-case", {
+            useCase: source,
+            outcome: "ok",
+            ms: elapsed(started)
+          });
+          endSpan(span);
+          return parsed.value;
+        } catch (error) {
+          logFailure(loggerOfCall(state), "use-case-failed", { useCase: source, ms: elapsed(started) }, error);
+          failSpan(span, error, ExceptionLayers.UseCase);
+          throw error;
+        } finally {
+          state.active = false;
+          state.resolved = undefined;
+          if (tracer !== undefined)
+            untrace(state);
+        }
+      }
+    });
+  }
+  get dependencies() {
+    const state = states.get(this);
+    return state?.resolved ?? state?.dependencies;
+  }
+  pullEvents() {
+    return states.get(this)?.events.splice(0) ?? [];
+  }
+}
+export function useCaseOf(settings) {
+  const { name, blueprint, response, context } = settings;
+  const { description, deprecated = false } = settings;
+  const tags = settings.tags === undefined ? [] : settings.tags;
+  const errors = settings.errors === undefined ? [] : settings.errors;
+  const dependencies = settings.dependencies === undefined ? {} : settings.dependencies;
+  if (typeof name !== "string" || !name.trim() || !isBlueprint(blueprint) || blueprint.optional || !isBlueprint(response) || response.optional || typeof dependencies !== "object" || dependencies === null || Array.isArray(dependencies) || Reflect.ownKeys(dependencies).some((key) => typeof key !== "string" || !isDependency(dependencies[key]))) {
+    throw new InvalidUseCaseDeclaration({
+      source: typeof name === "string" ? name : "useCaseOf",
+      details: {
+        reason: "Expected a name, input and response blueprints, and UseCase classes, repositories, environments or Logger as dependencies."
+      }
+    });
+  }
+  const invalidSetting = (reason) => {
+    throw new InvalidUseCaseDeclaration({ source: name, details: { reason } });
+  };
+  if (context !== undefined && (!isBlueprint(context) || context.optional)) {
+    invalidSetting("Expected context to be a non-optional blueprint.");
+  }
+  if (description !== undefined && typeof description !== "string") {
+    invalidSetting("Expected description to be a string.");
+  }
+  if (typeof deprecated !== "boolean") {
+    invalidSetting("Expected deprecated to be a boolean.");
+  }
+  if (settings.strictSteps !== undefined && typeof settings.strictSteps !== "boolean") {
+    invalidSetting("Expected strictSteps to be a boolean.");
+  }
+  if (!Array.isArray(tags) || tags.some((tag) => typeof tag !== "string" || tag === "") || new Set(tags).size !== tags.length) {
+    invalidSetting("Expected tags to be distinct, non-empty strings.");
+  }
+  if (!Array.isArray(errors) || !errors.every(isDeclaredException) || new Set(errors).size !== errors.length) {
+    invalidSetting("Expected errors to be distinct classes made by exceptionOf.");
+  }
+  let route;
+  if (settings.route !== undefined) {
+    const declared = routeDeclarationOf(settings.route, blueprint, response);
+    route = typeof declared === "string" ? invalidSetting(declared) : declared;
+  }
+  let access;
+  if (settings.access !== undefined) {
+    const declared = accessDeclarationOf(settings.access, blueprint);
+    access = typeof declared === "string" ? invalidSetting(declared) : declared;
+  }
+  if (settings.steps !== undefined) {
+    validateSteps({ name, blueprint, context, dependencies, errors }, settings.steps);
+  }
+
+  class DeclaredUseCase extends AbstractUseCase {
+    static [Kind] = "use-case";
+    static useCaseName = name;
+    static blueprint = blueprint;
+    static response = response;
+    static dependencies = Object.freeze({
+      ...dependencies
+    });
+    static context = context;
+    static description = description;
+    static tags = Object.freeze([...tags]);
+    static deprecated = deprecated;
+    static errors = Object.freeze([
+      ...errors
+    ]);
+    static route = route;
+    static access = access;
+  }
+  Object.defineProperty(DeclaredUseCase, "name", { value: name });
+  if (settings.steps !== undefined) {
+    Object.defineProperty(DeclaredUseCase, "steps", {
+      value: freezeData(settings.steps)
+    });
+    Object.defineProperty(DeclaredUseCase.prototype, "execute", {
+      value: executeSteps,
+      writable: true,
+      configurable: true
+    });
+  }
+  return DeclaredUseCase;
+}
+function isDependency(value) {
+  return isUseCaseClass(value) || isRepository(value) || isEnvironment(value) || isLoggerDeclaration(value);
+}
+export function isUseCaseClass(value) {
+  return typeof value === "function" && value.prototype instanceof AbstractUseCase && value[Kind] === "use-case" && typeof value.prototype.execute === "function";
+}
+export function isUseCase(value) {
+  return value instanceof AbstractUseCase;
+}

package/dist/experimental.d.ts

@@ -1,6 +1,23 @@
 /**
  * `@afora/core/experimental`: features that may change in any release. Not
- * covered by the compatibility policy in `VERSIONING.md`.
+ * covered by the compatibility policy in `VERSIONING.md`. See
+ * `docs/api-tiers.md`.
  */
+export { InvalidJwtOptions, jwtOf } from "./core/auth/jwt.js";
+export type { DescribedJwtOptions, Jwt, JwtAlgorithm, JwtOptions, JwtSubject, JwtTokenOptions, } from "./core/auth/types/jwt.interface.js";
 export { sliceOf, sliceValue } from "./core/blueprint/slice.js";
 export type { SlicedBlueprint, SlicedValue, SliceMask, ValueMask, } from "./core/blueprint/types/slice.interface.js";
+export { eventPolicyCatalogOf, eventPolicyDescriptionOf, } from "./core/event-policy/event-policy.js";
+export { stageDescriptionOf } from "./core/output/stage.js";
+export { type PropertyLineage, propertyLineageOf, } from "./core/property/lineage.js";
+export { providerDescriptionOf } from "./core/repository/provider.js";
+export { matchesQuery, prepareQuery, sameValue, selectRows, } from "./core/repository/query.js";
+export { useCaseOriginOf } from "./core/use-case/plugin.js";
+export { useCaseTargetOf } from "./core/use-case/target.js";
+export type { UseCaseOriginInfo } from "./core/use-case/types/plugin.interface.js";
+export type { StdTokenOptions } from "./std/use-cases/types.js";
+export type { EntityStorageSettings } from "./core/entity/types/entity.interface.js";
+export type { AbstractPropertyConstructor } from "./core/property/types/abstract-property-constructor.type.js";
+export type { IPropertyCollection } from "./core/property/types/property-collection.type.js";
+export type { RepositoryExists, RepositoryExplain, RepositoryFindCursor, RepositoryFindMany, RepositoryFindPage, RepositoryForEachPage, } from "./core/repository/types/query.interface.js";
+export type { RepositoryCount, RepositoryCreate, RepositoryDelete, RepositoryIncrement, RepositoryRestore, RepositoryUpdate, } from "./core/repository/types/repository.interface.js";

package/dist/experimental.js

@@ -1,124 +1,19 @@
-import {
-  isBlueprint2,
-  isRecordClass2,
-  recordFieldOf2,
-  recordNameOf2,
-  listOf2,
-  isBlueprintList2,
-  AbstractRecord2,
-  UndeclaredBlueprintProperty2,
-  optionalOf2,
-  blueprintFromProperties,
-  declareRecord
-} from "./index-qxfkyd6k.js";
-
-// src/core/blueprint/slice.ts
-function propertiesOfField(field) {
-  if (field === undefined)
-    return;
-  if (isBlueprintList2(field))
-    return propertiesOfField(field.item);
-  const record = recordFieldOf2(field);
-  if (record)
-    return record.record.blueprint.properties;
-  return isBlueprint2(field) ? field.properties : undefined;
-}
-function maskOf(selector, against) {
-  if (isRecordClass2(selector))
-    return maskOf(selector.blueprint, against);
-  if (isBlueprint2(selector)) {
-    return Object.fromEntries(Object.entries(selector.properties).map(([key, field]) => [key, fieldMaskOf(field, against?.[key])]));
-  }
-  return selector;
-}
-function fieldMaskOf(field, other) {
-  if (isBlueprintList2(field)) {
-    return fieldMaskOf(field.item, isBlueprintList2(other) ? other.item : other);
-  }
-  const record = recordFieldOf2(field);
-  if (record) {
-    if (record.record === recordFieldOf2(other)?.record)
-      return true;
-    return maskOf(record.record, propertiesOfField(other));
-  }
-  if (isBlueprint2(field)) {
-    return field === other ? true : maskOf(field, propertiesOfField(other));
-  }
-  return true;
-}
-function sliceCollection(properties, mask, path) {
-  const sliced = {};
-  for (const [key, selected] of Object.entries(mask)) {
-    if (!selected)
-      continue;
-    if (!Object.hasOwn(properties, key)) {
-      throw new UndeclaredBlueprintProperty2({
-        source: "blueprint",
-        details: { key: path + key }
-      });
-    }
-    sliced[key] = sliceField(properties[key], selected, path + key);
-  }
-  return sliced;
-}
-function slicedRecordOf(Original, mask, path) {
-  const source = Original.blueprint;
-  const blueprint = blueprintFromProperties(source.plugins, sliceCollection(source.properties, mask, `${path}.`));
-  const kept = (keys) => keys.filter((key) => Object.hasOwn(blueprint.properties, key));
-  const { sensitive, unique, change } = Original.options;
-  const Sliced = declareRecord(AbstractRecord2, blueprint, {
-    sensitive: kept(sensitive),
-    unique: kept(unique),
-    change: kept(change)
-  }, recordNameOf2(Original));
-  Object.defineProperty(Sliced, Symbol.hasInstance, {
-    value(value) {
-      return Function.prototype[Symbol.hasInstance].call(this, value) || value instanceof Original;
-    }
-  });
-  return Sliced;
-}
-function sliceField(field, selected, path) {
-  if (selected === true)
-    return field;
-  if (isBlueprintList2(field)) {
-    const list = listOf2(sliceField(field.item, selected, path), {
-      minItems: field.minItems,
-      maxItems: field.maxItems
-    });
-    return field.optional ? optionalOf2(list) : list;
-  }
-  const record = recordFieldOf2(field);
-  if (record) {
-    const sliced = slicedRecordOf(record.record, selected, path);
-    return record.optional ? optionalOf2(sliced) : sliced;
-  }
-  if (isBlueprint2(field)) {
-    const sliced = blueprintFromProperties(field.plugins, sliceCollection(field.properties, selected, `${path}.`));
-    return field.optional ? optionalOf2(sliced) : sliced;
-  }
-  throw new UndeclaredBlueprintProperty2({
-    source: "blueprint",
-    details: { key: `${path}.${Object.keys(selected)[0] ?? ""}` }
-  });
-}
-var sliceOf = (blueprint, selector) => blueprintFromProperties(blueprint.plugins, sliceCollection(blueprint.properties, maskOf(selector, blueprint.properties), ""));
-var sliceValue = (value, selector) => pick(value, maskOf(selector));
-function pick(value, mask) {
-  if (Array.isArray(value))
-    return value.map((item) => pick(item, mask));
-  if (typeof value !== "object" || value === null)
-    return value;
-  const source = isRecordClass2(value.constructor) ? value.toJSON() : value;
-  const picked = {};
-  for (const [key, selected] of Object.entries(mask)) {
-    if (!selected || !Object.hasOwn(source, key))
-      continue;
-    picked[key] = selected === true ? source[key] : pick(source[key], selected);
-  }
-  return picked;
-}
+export { InvalidJwtOptions, jwtOf } from "./core/auth/jwt.js";
+export { sliceOf, sliceValue } from "./core/blueprint/slice.js";
 export {
-  sliceOf,
-  sliceValue
-};
+  eventPolicyCatalogOf,
+  eventPolicyDescriptionOf
+} from "./core/event-policy/event-policy.js";
+export { stageDescriptionOf } from "./core/output/stage.js";
+export {
+  propertyLineageOf
+} from "./core/property/lineage.js";
+export { providerDescriptionOf } from "./core/repository/provider.js";
+export {
+  matchesQuery,
+  prepareQuery,
+  sameValue,
+  selectRows
+} from "./core/repository/query.js";
+export { useCaseOriginOf } from "./core/use-case/plugin.js";
+export { useCaseTargetOf } from "./core/use-case/target.js";