@afora/core 0.0.8 → 0.0.11

package/dist/core/repository/repository.js

@@ -0,0 +1,720 @@
+import { fieldOf } from "../blueprint/callable.js";
+import { isBlueprint } from "../blueprint/is-blueprint.js";
+import { isBlueprintList } from "../blueprint/list.js";
+import { recordFieldOf } from "../blueprint/record-field.js";
+import { isBlueprintVariant } from "../blueprint/variant.js";
+import {
+  EntityClock,
+  EntitySettings,
+  EntityUniqueKeys,
+  identityKeysOf,
+  isVersionedEntityClass,
+  storeEntityVersion
+} from "../entity/abstract-entity.js";
+import { isEntity, isEntityClass } from "../entity/entity.js";
+import { enqueueLifecycle } from "../entity/event.js";
+import { InvalidEntitySchemaVersion } from "../entity/exceptions.js";
+import {
+  isEnvironment
+} from "../environment/environment.js";
+import { ExceptionLayers } from "../exception/enums/exception-layers.js";
+import { Exception } from "../exception/exception.js";
+import { guard } from "../exception/guard.js";
+import { resolveLogger, writeLog } from "../logger/logger.js";
+import { isProperty } from "../property/is-property.js";
+import {
+  recordDataOf,
+  recordFieldDataOf
+} from "../record/abstract-record.js";
+import { recordNameOf } from "../record/name.js";
+import { rawTypeOf } from "../schema/schema.js";
+import { Kind } from "../symbols/kind.js";
+import { ScopeKey } from "../use-case/scope.js";
+import { decodeCursor, encodeCursor } from "./cursor.js";
+import {
+  InvalidRepositoryDeclaration,
+  InvalidRepositoryEntity,
+  InvalidRepositoryIncrement,
+  InvalidRepositoryQuery,
+  RepositoryConcurrencyConflict,
+  RepositoryEntityNotFound
+} from "./exceptions.js";
+import { inMemoryProvider } from "./in-memory.js";
+import { planQuery } from "./plan.js";
+import { prepareQuery } from "./query.js";
+import { parseEntity, relationsOf, resolveReferences } from "./references.js";
+import {
+  assertUnbound,
+  contextOf,
+  declareRepository,
+  stateOf,
+  states
+} from "./state.js";
+import {
+  fullUpcastPlanOf,
+  upcast,
+  upcastRows,
+  withSchemaVersion
+} from "./upcast.js";
+const REFERENCES = {
+  reference: (record) => isEntity(record) ? record.id : undefined
+};
+
+export class AbstractRepository {
+  get [Kind]() {
+    return "repository";
+  }
+  get entity() {
+    return stateOf(this).entity;
+  }
+  get actions() {
+    return stateOf(this).actions;
+  }
+  get provider() {
+    return stateOf(this).provider;
+  }
+  get context() {
+    return contextOf(stateOf(this));
+  }
+  get env() {
+    return this.context.env;
+  }
+  async hydrate(data) {
+    return (await this.hydrateMany([data]))[0];
+  }
+  async hydrateMany(list) {
+    const state = stateOf(this);
+    const scope = this[ScopeKey];
+    const resolved = await resolveReferences(state, upcastRows(state, list), new Map, scope);
+    return resolved.map((data) => parseEntity(state, data));
+  }
+  dataOf(entity) {
+    if (!(entity instanceof stateOf(this).entity)) {
+      throw new InvalidRepositoryEntity({ source: stateOf(this).name });
+    }
+    return withSchemaVersion(stateOf(this).entity, recordDataOf(entity, REFERENCES));
+  }
+}
+function action(method) {
+  return function(...args) {
+    const state = stateOf(this);
+    return guard({ layer: ExceptionLayers.Repository, source: state.name }, async () => {
+      assertUnbound(state);
+      return method(this, ...args);
+    });
+  };
+}
+function queryValueOf(context, key, value) {
+  const properties = context.entity.blueprint.properties;
+  return recordFieldDataOf(properties[key], value, REFERENCES);
+}
+function expiryOf(self, withExpired) {
+  const { context, provider } = self;
+  if (context.expiry === undefined)
+    return {};
+  if (provider.capabilities?.expiry !== true) {
+    throw new InvalidRepositoryQuery({
+      source: context.name,
+      details: {
+        reason: "The provider does not leave expired records out (capabilities.expiry), which an entity with expires needs."
+      }
+    });
+  }
+  const clock = context.entity[EntityClock];
+  return { withExpired: withExpired ?? false, now: clock.now() };
+}
+function queryOf(self, query) {
+  const prepared = prepareQuery(self.context, query, (key, value) => queryValueOf(self.context, key, value));
+  return {
+    ...prepared,
+    withDeleted: prepared.withDeleted ?? stateOf(self).deletion === "hard",
+    ...expiryOf(self, prepared.withExpired)
+  };
+}
+const equals = (self, key, value) => queryOf(self, { where: { [key]: value } });
+function planned(self, method, query, orderBy = query.orderBy) {
+  const state = stateOf(self);
+  const plan = planQuery(self.context, { where: query.where, orderBy });
+  if (plan.access === "scan" && state.scans !== "allow") {
+    const fields = {
+      repository: state.name,
+      method,
+      where: Object.keys(query.where ?? {}),
+      orderBy: (orderBy ?? []).map(({ key }) => key)
+    };
+    if (state.scans === "reject") {
+      throw new InvalidRepositoryQuery({
+        source: state.name,
+        details: {
+          reason: `"${method}" matches no index of ${state.name} and would read every row (scans: "reject").`,
+          scan: true,
+          ...fields
+        }
+      });
+    }
+    const scope = self[ScopeKey];
+    writeLog(resolveLogger(scope?.logger ?? state.logger, undefined), "warn", "repository-scan", fields);
+  }
+  return plan.index === undefined ? query : { ...query, index: plan.index };
+}
+const findBy = (key) => action(async (self, value) => {
+  const data = await self.provider.findOne(self.context, equals(self, key, value));
+  return data === undefined ? undefined : await self.hydrate(data);
+});
+const findManyBy = (key) => action(async (self, value) => self.hydrateMany(await self.provider.findMany(self.context, planned(self, `findManyBy${capitalize(key)}`, equals(self, key, value)))));
+const findMany = action(async (self, query) => self.hydrateMany(await self.provider.findMany(self.context, planned(self, "findMany", queryOf(self, query)))));
+const exists = action(async (self, query) => await self.provider.findOne(self.context, planned(self, "exists", queryOf(self, query))) !== undefined);
+const EXPLAIN_OPTIONS = [
+  "where",
+  "orderBy",
+  "limit",
+  "offset",
+  "withDeleted",
+  "after"
+];
+const explain = action(async (self, query = {}) => {
+  const prepared = prepareQuery(self.context, query, (key, value) => queryValueOf(self.context, key, value), EXPLAIN_OPTIONS);
+  return planQuery(self.context, prepared);
+});
+const findPage = action(async (self, query) => {
+  const {
+    orderBy,
+    where,
+    withDeleted,
+    withExpired,
+    now,
+    limit = 20,
+    offset = 0,
+    index
+  } = planned(self, "findPage", queryOf(self, query));
+  const expiry = withExpired === undefined ? {} : { withExpired, now };
+  const [rows, total] = await Promise.all([
+    self.provider.findMany(self.context, {
+      where,
+      orderBy,
+      withDeleted,
+      ...expiry,
+      limit,
+      offset,
+      ...index === undefined ? {} : { index }
+    }),
+    self.provider.count(self.context, {
+      where,
+      withDeleted,
+      ...expiry,
+      ...index === undefined ? {} : { index }
+    })
+  ]);
+  return { items: await self.hydrateMany(rows), total, limit, offset };
+});
+const CURSOR_OPTIONS = [
+  "where",
+  "orderBy",
+  "limit",
+  "withDeleted",
+  "withExpired",
+  "after"
+];
+function cursorReadOf(self, query) {
+  const { context } = self;
+  const fail = (reason) => {
+    throw new InvalidRepositoryQuery({
+      source: context.name,
+      details: { reason }
+    });
+  };
+  const prepared = prepareQuery(context, query, (key, value) => queryValueOf(context, key, value), CURSOR_OPTIONS);
+  const { where, limit = 20 } = prepared;
+  if (limit < 1)
+    fail("Expected a positive integer for limit.");
+  const withDeleted = prepared.withDeleted ?? stateOf(self).deletion === "hard";
+  const declared = prepared.orderBy ?? [];
+  const orderBy = declared.some(({ key }) => key === "id") ? declared : [...declared, { key: "id", direction: "asc" }];
+  for (const { key } of orderBy) {
+    if (context.entity.options.sensitive.includes(key))
+      fail(`"${key}" is sensitive and cannot order a cursor.`);
+  }
+  if (self.provider.capabilities?.keyset !== true)
+    fail("The provider does not read by cursor (capabilities.keyset).");
+  const { index } = planned(self, "findCursor", { where }, declared);
+  expiryOf(self, prepared.withExpired);
+  return {
+    where,
+    orderBy,
+    withDeleted,
+    withExpired: prepared.withExpired,
+    limit,
+    ...index === undefined ? {} : { index }
+  };
+}
+async function readCursor(self, read, after) {
+  const { context } = self;
+  const { where, orderBy, withDeleted, limit, index } = read;
+  const rows = await self.provider.findMany(context, {
+    where,
+    orderBy,
+    withDeleted,
+    ...expiryOf(self, read.withExpired),
+    limit: limit + 1,
+    ...index === undefined ? {} : { index },
+    ...after === undefined ? {} : { after: decodeCursor(context.name, orderBy, after) }
+  });
+  const page = rows.slice(0, limit);
+  const last = page.at(-1);
+  return {
+    items: await self.hydrateMany(page),
+    limit,
+    next: rows.length > limit && last !== undefined ? encodeCursor(orderBy, last) : undefined
+  };
+}
+const findCursor = action(async (self, query = {}) => readCursor(self, cursorReadOf(self, query), query.after));
+function stopperOf(source, until) {
+  if (until === undefined)
+    return () => false;
+  if (typeof until === "function")
+    return () => Boolean(until());
+  const deadline = until instanceof Date ? until.getTime() : typeof until === "number" ? until : Number.NaN;
+  if (Number.isNaN(deadline)) {
+    throw new InvalidRepositoryQuery({
+      source,
+      details: {
+        reason: "Expected until to be a Date, epoch milliseconds or a function."
+      }
+    });
+  }
+  return () => Date.now() >= deadline;
+}
+const forEachPage = action(async (self, query, fn, options) => {
+  const { context } = self;
+  if (typeof fn !== "function") {
+    throw new InvalidRepositoryQuery({
+      source: context.name,
+      details: { reason: "Expected a function to run on each page." }
+    });
+  }
+  const read = cursorReadOf(self, query ?? {});
+  const stop = stopperOf(context.name, options?.until);
+  let after = query?.after;
+  let pages = 0;
+  let items = 0;
+  while (!stop()) {
+    const page = await readCursor(self, read, after);
+    if (page.items.length > 0) {
+      await fn(page.items, { index: pages, next: page.next });
+      pages += 1;
+      items += page.items.length;
+    }
+    if (page.next === undefined)
+      return { done: true, pages, items };
+    after = page.next;
+  }
+  return { done: false, next: after, pages, items };
+});
+const create = action(async (self, input) => {
+  const { entity: Entity } = self.context;
+  const entity = input instanceof Entity ? input : new Entity(input);
+  await self.provider.insert(self.context, self.dataOf(entity));
+  return entity;
+});
+function nowOf(context) {
+  return context.entity[EntityClock].now();
+}
+function assertVersioning(self) {
+  if (self.provider.capabilities?.versioning === true)
+    return;
+  invalid(self.context.name, `${recordNameOf(self.context.entity)} is versioned, and the provider does not check versions (capabilities.versioning).`);
+}
+async function write(self, data) {
+  if (!isVersionedEntityClass(self.context.entity)) {
+    await self.provider.update(self.context, data);
+    return data;
+  }
+  assertVersioning(self);
+  const expected = data.version;
+  const next = { ...data, version: expected + 1 };
+  await self.provider.update(self.context, next, {
+    expectedVersion: expected
+  });
+  return next;
+}
+async function writeEntity(self, entity) {
+  const written = await write(self, self.dataOf(entity));
+  if (written.version !== undefined && isEntity(entity)) {
+    storeEntityVersion(entity, written.version);
+  }
+}
+const update = action(async (self, entity) => {
+  await writeEntity(self, entity);
+  return entity;
+});
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNumericField(field) {
+  if (field === undefined)
+    return false;
+  const property = fieldOf(field);
+  if (!isProperty(property))
+    return false;
+  const { type } = rawTypeOf(property.type.schema);
+  return type === "number" || type === "integer";
+}
+function deltasOf(context, deltas) {
+  const { name: source } = context;
+  const fail = (reason, issues) => {
+    throw new InvalidRepositoryIncrement({
+      source,
+      details: { reason, issues }
+    });
+  };
+  if (!isPlainObject(deltas) || Object.keys(deltas).length === 0) {
+    const message = "Expected an object of the numbers to add, by key.";
+    fail(message, [{ code: "invalid_type", path: [], message, source }]);
+  }
+  const { change } = context.entity.options;
+  const properties = context.entity.blueprint.properties;
+  const issues = [];
+  for (const [key, value] of Object.entries(deltas)) {
+    if (!change.includes(key) || !isNumericField(properties[key])) {
+      issues.push({
+        code: "undeclared_key",
+        path: [key],
+        message: `"${key}" is not a number in the change list of ${recordNameOf(context.entity)}.`,
+        source
+      });
+    } else if (typeof value !== "number" || !Number.isFinite(value)) {
+      issues.push({
+        code: "invalid_value",
+        path: [key],
+        message: "Expected a finite number.",
+        source
+      });
+    }
+  }
+  if (issues.length > 0) {
+    fail(`"${source}" cannot increment ${issues.map((issue) => `"${issue.path[0]}"`).join(", ")}.`, issues);
+  }
+  return deltas;
+}
+function createdOf(context, id, input, deltas) {
+  const identity = identityKeysOf(context.entity);
+  const value = isPlainObject(input) ? Object.fromEntries(Object.entries(input).filter(([key]) => !identity.includes(key))) : {};
+  for (const [key, delta] of Object.entries(deltas)) {
+    const base = value[key];
+    value[key] = (typeof base === "number" ? base : 0) + delta;
+  }
+  const Entity = context.entity;
+  const entity = new Entity({ ...value, id });
+  enqueueLifecycle(entity, "onCreate");
+  return entity;
+}
+function renamedFromOf(field) {
+  if (field === undefined)
+    return;
+  const property = fieldOf(field);
+  if (!isProperty(property))
+    return;
+  const { renamedFrom } = property.type;
+  return typeof renamedFrom === "string" ? renamedFrom : undefined;
+}
+async function bringUpRenamed(self, id, deltas) {
+  const { context } = self;
+  const properties = context.entity.blueprint.properties;
+  const renamed = [];
+  for (const key of Object.keys(deltas)) {
+    const from = renamedFromOf(properties[key]);
+    if (from !== undefined)
+      renamed.push([key, from]);
+  }
+  if (renamed.length === 0)
+    return;
+  const stored = await self.provider.findOne(context, {
+    where: { id },
+    withDeleted: true,
+    ...context.expiry === undefined ? {} : { withExpired: true }
+  });
+  if (stored === undefined || !renamed.some(([key, from]) => stored[key] === undefined && Object.hasOwn(stored, from))) {
+    return;
+  }
+  const data = withSchemaVersion(context.entity, upcast(context.name, fullUpcastPlanOf(context.entity), stored, false));
+  const expected = stored.version;
+  try {
+    await self.provider.update(context, data, isVersionedEntityClass(context.entity) && typeof expected === "number" ? { expectedVersion: expected } : undefined);
+  } catch (error) {
+    if (!(error instanceof Exception) || !error.is(RepositoryConcurrencyConflict)) {
+      throw error;
+    }
+  }
+}
+const increment = action(async (self, target, deltas, options) => {
+  const { context } = self;
+  const id = typeof target === "string" ? target : self.dataOf(target).id;
+  const checked = deltasOf(context, deltas);
+  if (options !== undefined && !isPlainObject(options)) {
+    invalid(context.name, "Expected the options of increment as an object.");
+  }
+  const versioned = isVersionedEntityClass(context.entity);
+  if (versioned)
+    assertVersioning(self);
+  const { create } = options ?? {};
+  const created = create === undefined ? undefined : createdOf(context, id, create, checked);
+  await bringUpRenamed(self, id, checked);
+  const stored = await self.provider.increment(context, id, versioned ? { ...checked, version: 1 } : checked, {
+    set: { updatedAt: nowOf(context) },
+    ...created === undefined ? {} : { create: self.dataOf(created) },
+    ...context.expiry === undefined ? {} : { now: expiryOf(self, false).now }
+  });
+  if (created !== undefined && stored.updatedAt === undefined)
+    return created;
+  const entity = await self.hydrate(stored);
+  enqueueLifecycle(entity, "onUpdate");
+  return entity;
+});
+const remove = action(async (self, target) => {
+  const { context } = self;
+  let entity = target;
+  if (typeof target === "string") {
+    const data = await self.provider.findOne(context, equals(self, "id", target));
+    if (data === undefined) {
+      throw new RepositoryEntityNotFound({
+        source: context.name,
+        details: { id: target }
+      });
+    }
+    entity = await self.hydrate(data);
+  }
+  const data = self.dataOf(entity);
+  const destroyable = entity;
+  if (!destroyable.isDeleted)
+    destroyable.destroy();
+  if (stateOf(self).deletion === "soft") {
+    await writeEntity(self, entity);
+  } else {
+    await self.provider.remove(context, data.id);
+  }
+  return entity;
+});
+const restore = action(async (self, target) => {
+  const { context } = self;
+  const id = typeof target === "string" ? target : self.dataOf(target).id;
+  const data = await self.provider.findOne(context, {
+    ...equals(self, "id", id),
+    withDeleted: true
+  });
+  if (data === undefined) {
+    throw new RepositoryEntityNotFound({
+      source: context.name,
+      details: { id }
+    });
+  }
+  if (data.deletedAt === undefined)
+    return self.hydrate(data);
+  const [current] = upcastRows(stateOf(self), [data]);
+  const { deletedAt: _deletedAt, ...alive } = current;
+  const restored = withSchemaVersion(context.entity, {
+    ...alive,
+    updatedAt: nowOf(context)
+  });
+  return self.hydrate(await write(self, restored));
+});
+const count = action(async (self, query) => {
+  const prepared = queryOf(self, query);
+  return self.provider.count(self.context, planned(self, "count", prepared, []));
+});
+const NEEDS = {
+  findBy: ["findOne"],
+  findManyBy: ["findMany"],
+  create: ["insert"],
+  update: ["update"],
+  delete: ["findOne", "remove"],
+  restore: ["findOne", "update"],
+  count: ["count"],
+  findMany: ["findMany"],
+  exists: ["findOne"],
+  findPage: ["findMany", "count"],
+  findCursor: ["findMany"],
+  explain: [],
+  increment: ["increment"],
+  forEachPage: ["findMany"]
+};
+function capitalize(key) {
+  return `${key.charAt(0).toUpperCase()}${key.slice(1)}`;
+}
+function unknownAction(entity, action, methods) {
+  const many = /^findManyBy(.+)$/.exec(action)?.[1];
+  const one = many === undefined ? /^findBy(.+)$/.exec(action)?.[1] : undefined;
+  const suffix = many ?? one;
+  const key = suffix === undefined ? undefined : `${suffix.charAt(0).toLowerCase()}${suffix.slice(1)}`;
+  if (one !== undefined && methods.has(`findManyBy${one}`)) {
+    return `"${action}" requires "${key}" to be a unique key of ${entity}.`;
+  }
+  if (many !== undefined && methods.has(`findBy${many}`)) {
+    return `"${action}" is not available for the unique key "${key}" of ${entity}; use "findBy${many}".`;
+  }
+  return `"${action}" is not an action of ${entity}.`;
+}
+function invalid(source, reason) {
+  throw new InvalidRepositoryDeclaration({ source, details: { reason } });
+}
+function assertPreviousNames(entity) {
+  const own = recordNameOf(entity);
+  const previous = entity[EntitySettings]?.previousNames ?? [];
+  if (!previous.includes(own))
+    return;
+  throw new InvalidEntitySchemaVersion({
+    source: own,
+    details: {
+      reason: `"${own}" cannot be a previous name: expected an identifier other than the name of the entity.`
+    }
+  });
+}
+const INDEX_NAME = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function indexesOf(name, entity, declared) {
+  if (declared === undefined)
+    return Object.freeze({});
+  if (typeof declared !== "object" || declared === null || Array.isArray(declared)) {
+    invalid(name, "Expected indexes to be an object of indexes by name.");
+  }
+  const properties = entity.blueprint.properties;
+  const sensitive = entity.options.sensitive;
+  const keyOf = (index, key) => {
+    if (typeof key !== "string" || !Object.hasOwn(properties, key)) {
+      invalid(name, `The index "${index}" names "${String(key)}", which is not a key of ${recordNameOf(entity)}.`);
+    }
+    if (sensitive.includes(key)) {
+      invalid(name, `The index "${index}" names "${key}", which is sensitive and cannot be indexed.`);
+    }
+    return key;
+  };
+  const seen = new Map;
+  const indexes = {};
+  for (const [index, value] of Object.entries(declared)) {
+    if (!INDEX_NAME.test(index) || index === "__proto__") {
+      invalid(name, `Expected the index "${index}" to be named by an identifier.`);
+    }
+    if (typeof value !== "object" || value === null || Array.isArray(value) || Object.keys(value).some((key) => key !== "where" && key !== "orderBy") || !Array.isArray(value.where) || value.where.length === 0) {
+      invalid(name, `Expected the index "${index}" to be { where: [keys], orderBy?: key }.`);
+    }
+    const where = value.where.map((key) => keyOf(index, key));
+    if (new Set(where).size !== where.length) {
+      invalid(name, `The index "${index}" names a key twice in where.`);
+    }
+    const orderBy = value.orderBy === undefined ? undefined : keyOf(index, value.orderBy);
+    if (orderBy !== undefined) {
+      const field = properties[orderBy];
+      if (isBlueprint(field) || isBlueprintList(field) || isBlueprintVariant(field) || recordFieldOf(field)) {
+        invalid(name, `The index "${index}" orders by "${orderBy}", which is not scalar.`);
+      }
+    }
+    const signature = JSON.stringify([[...where].sort(), orderBy ?? null]);
+    const other = seen.get(signature);
+    if (other !== undefined) {
+      invalid(name, `The indexes "${other}" and "${index}" are the same.`);
+    }
+    seen.set(signature, index);
+    indexes[index] = Object.freeze({
+      where: Object.freeze(where),
+      ...orderBy === undefined ? {} : { orderBy }
+    });
+  }
+  return Object.freeze(indexes);
+}
+export function repositoryOf(settings) {
+  const { entity, actions, environmentDependencies } = settings ?? {};
+  if (!isEntityClass(entity) || !(EntityUniqueKeys in entity)) {
+    invalid("repositoryOf", "Expected an entity class made by entityOf.");
+  }
+  const name = `${recordNameOf(entity)}Repository`;
+  assertPreviousNames(entity);
+  const deletion = settings.deletion ?? "hard";
+  if (deletion !== "hard" && deletion !== "soft") {
+    invalid(name, 'Expected deletion to be "hard" or "soft".');
+  }
+  const scans = settings.scans ?? "allow";
+  if (scans !== "allow" && scans !== "warn" && scans !== "reject") {
+    invalid(name, 'Expected scans to be "allow", "warn" or "reject".');
+  }
+  const provider = settings.provider ?? inMemoryProvider();
+  if (!Array.isArray(actions) || actions.length === 0) {
+    invalid(name, "Expected a list of actions.");
+  }
+  if (environmentDependencies !== undefined && !isEnvironment(environmentDependencies) && !(Array.isArray(environmentDependencies) && environmentDependencies.every(isEnvironment))) {
+    invalid(name, "Expected environments made by environmentOf.");
+  }
+  const relations = relationsOf(name, entity, settings.relations);
+  const indexes = indexesOf(name, entity, settings.indexes);
+  const unique = entity[EntityUniqueKeys];
+  const methods = new Map;
+  for (const key of Object.keys(entity.blueprint.properties)) {
+    const suffix = capitalize(key);
+    if (unique.includes(key)) {
+      methods.set(`findBy${suffix}`, ["findBy", findBy(key)]);
+    } else {
+      methods.set(`findManyBy${suffix}`, ["findManyBy", findManyBy(key)]);
+    }
+  }
+  methods.set("create", ["create", create]);
+  methods.set("update", ["update", update]);
+  methods.set("delete", ["delete", remove]);
+  methods.set("restore", ["restore", restore]);
+  methods.set("count", ["count", count]);
+  methods.set("findMany", ["findMany", findMany]);
+  methods.set("exists", ["exists", exists]);
+  methods.set("findPage", ["findPage", findPage]);
+  methods.set("findCursor", ["findCursor", findCursor]);
+  methods.set("explain", ["explain", explain]);
+  methods.set("increment", ["increment", increment]);
+  methods.set("forEachPage", ["forEachPage", forEachPage]);
+
+  class DeclaredRepository extends AbstractRepository {
+  }
+  for (const name_ of new Set(actions)) {
+    const method = typeof name_ === "string" ? methods.get(name_) : undefined;
+    if (!method)
+      invalid(name, unknownAction(recordNameOf(entity), String(name_), methods));
+    const [kind, implementation] = method;
+    if (kind === "restore" && deletion !== "soft") {
+      invalid(name, '"restore" needs deletion to be "soft".');
+    }
+    if (kind === "findCursor" && settings.provider !== undefined && provider[Kind] !== "provider-slot" && provider.capabilities?.keyset !== true) {
+      invalid(name, '"findCursor" needs a provider that reads by cursor (capabilities.keyset).');
+    }
+    const needs = deletion === "soft" && kind === "delete" ? ["findOne", "update"] : NEEDS[kind] ?? [];
+    for (const need of needs) {
+      if (typeof provider?.[need] !== "function") {
+        invalid(name, `The provider has no "${need}" for "${name_}".`);
+      }
+    }
+    Object.defineProperty(DeclaredRepository.prototype, name_, {
+      value: implementation,
+      writable: true,
+      configurable: true
+    });
+  }
+  Object.defineProperty(DeclaredRepository, "name", { value: name });
+  const state = {
+    name,
+    entity,
+    actions: Object.freeze([...new Set(actions)]),
+    deletion,
+    provider,
+    explicitProvider: settings.provider !== undefined,
+    environment: environmentDependencies,
+    relations,
+    indexes,
+    scans
+  };
+  states.set(DeclaredRepository, state);
+  const repository = Object.freeze(new DeclaredRepository);
+  declareRepository(state, repository);
+  return repository;
+}
+export function RepositoryOf(repository) {
+  if (!isRepository(repository)) {
+    invalid("RepositoryOf", "Expected a repository made by repositoryOf.");
+  }
+  return repository.constructor;
+}
+export function isRepository(value) {
+  return value instanceof AbstractRepository;
+}