@jwilleke/ngdpbase-types 5.32.0 → 5.34.0

package/lib/src/managers/BackupManager.js

@@ -1200,7 +1200,7 @@ class BackupManager extends BaseManager {
     async notifyAdmins(level, title, message) {
         try {
             await this.engine.getManager('NotificationManager')
-                ?.addNotification({ type: 'system', level, title, message });
+                ?.notifyAdmins({ level, title, message });
         }
         catch (err) {
             logger.error(`❌ The notification '${title}' could not be sent:`, err);
@@ -2059,8 +2059,8 @@ class BackupManager extends BaseManager {
         catch (err) {
             jobs.registerJob(def);
             logger.error(`❌ Automatic backups are ON but NOT scheduled: ${err.message}. Fix the setting in Admin → Backup.`);
-            void this.engine.getManager('NotificationManager')?.addNotification({
-                type: 'system', level: 'error', title: 'Automatic backups are not running',
+            void this.engine.getManager('NotificationManager')?.notifyAdmins({
+                level: 'error', title: 'Automatic backups are not running',
                 message: `${err.message}. Fix the setting in Admin → Backup.`
             }).catch(() => undefined);
         }

package/lib/src/managers/CommentManager.d.ts

@@ -10,6 +10,31 @@ export default class CommentManager extends BaseManager {
     private readonly outsideCheck;
     constructor(engine: WikiEngine);
     initialize(): Promise<void>;
+    /**
+     * Once, at start-up (#2041): every public comment whose `author` is still a
+     * username gets `IdentityManager.convertReference`'s answer, one write per
+     * comment file, under the system context: that user's identity `@id`, or
+     * `orphan:<name>` when the name has no account (nobody's from then on: a
+     * later account with that name never takes it over, and only an
+     * administrator can delete it). `@id`s, orphans, `anonymous` and the system
+     * principal are left alone, so a second start writes nothing. Orphans are
+     * reported, counts only: a log line and the admin dashboard's
+     * needs-attention list. When the identity store cannot answer, the whole
+     * pass is postponed to the next start and reported the same way. A vault
+     * page's comments are in its vault, which start-up does not open; they keep
+     * their username, and {@link isAuthor} still matches it.
+     * `authorDisplayName` and `deletedBy` are not touched.
+     */
+    private convertAuthorsToIdentityIds;
+    /** The identity store could not answer: nothing more is converted this start, and the next start tries again (#2041). */
+    private postponeConversion;
+    /**
+     * Whether `ctx` wrote `comment` (#2041): its `author` is the caller's
+     * identity `@id`, or, on a comment written before and not yet converted (a
+     * vault page's), the caller's username. An orphan (`orphan:<name>`) is
+     * nobody's and never matches.
+     */
+    isAuthor(comment: Pick<PageComment, 'author'>, ctx: ActorContext): Promise<boolean>;
     /** `ngdpbase.comments.storagedir`, resolved, or the default when there is no configuration (a test). */
     private configuredDir;
     /**

package/lib/src/managers/DatabaseManager.js

@@ -713,7 +713,7 @@ class DatabaseManager extends BaseManager {
     async notify(level, title, message) {
         try {
             await this.engine.getManager('NotificationManager')
-                ?.addNotification({ type: 'system', level, title, message });
+                ?.notifyAdmins({ level, title, message });
         }
         catch (err) {
             logger.error(`[DatabaseManager] The notification '${title}' could not be sent (#1723):`, err);

package/lib/src/managers/FootnoteManager.d.ts

@@ -7,6 +7,7 @@ export interface PageFootnote {
     display: string;
     url: string;
     note: string;
+    /** Who added it: their identity `@id` (#2041); a username on a note written before and not yet converted (a vault page's), or one with no account. */
     createdBy: string;
     createdAt: string;
 }
@@ -17,6 +18,32 @@ export default class FootnoteManager extends BaseManager {
     private readonly outsideCheck;
     constructor(engine: WikiEngine);
     initialize(): Promise<void>;
+    /**
+     * Once, at start-up (#2041): every public footnote whose `createdBy` is
+     * still a username gets `IdentityManager.convertReference`'s answer, one
+     * write per page file, under the system context: that user's identity
+     * `@id`, or `orphan:<name>` when the name has no account (nobody's from
+     * then on: a later account with that name never takes it over, and only an
+     * administrator can delete it). `@id`s, orphans, `anonymous` and the system
+     * principal are left alone, so a second start writes nothing. Orphans are
+     * reported, counts only (the legacy `migrated` placeholder is `orphan:migrated`
+     * and only logged at info, not counted: it has no recorded creator): a log line and the admin dashboard's
+     * needs-attention list. When the identity store cannot answer, the whole
+     * pass is postponed to the next start and reported the same way. A vault
+     * page's footnotes are in its vault, which start-up does not open; they
+     * keep their username, and {@link isCreator} still matches it.
+     */
+    private convertCreatorsToIdentityIds;
+    /** The identity store could not answer: nothing more is converted this start, and the next start tries again (#2041). */
+    private postponeConversion;
+    /**
+     * Whether `ctx` added `footnote` (#2041): its `createdBy` is the caller's
+     * identity `@id`, or, on a footnote written before and not yet converted
+     * (a vault page's), the caller's username. An orphan (`orphan:<name>`)
+     * is nobody's and never matches; neither does the legacy `migrated`
+     * placeholder (no recorded creator), on a footnote not yet converted.
+     */
+    isCreator(footnote: Pick<PageFootnote, 'createdBy'>, ctx: ActorContext): Promise<boolean>;
     /** `ngdpbase.footnotes.storagedir`, resolved, or the default when there is no configuration (a test). */
     private configuredDir;
     /**

package/lib/src/managers/IdentityManager.d.ts

@@ -272,6 +272,43 @@ declare class IdentityManager extends BaseManager {
      * (an administrator links it, {@link linkAccount}).
      */
     getByUserIdentifier(ctx: ActorContext, username: string): Promise<Person | null>;
+    /**
+     * The `@id` of the user `username`'s identity record, or null (#2041): null
+     * when there is no account by that name, and null when the identity store
+     * cannot answer (degraded, unreadable), logged without the name. The door
+     * for a write or a record that refers to a user: it then keeps working as
+     * it does for a name with no account, and never fails because the identity
+     * store is down. Read as {@link getByUserIdentifier}, which a caller that
+     * must tell "no account" from "cannot answer" uses instead (a start-up
+     * conversion, with {@link canAnswer}). A refusal still throws.
+     */
+    identityIdOf(ctx: ActorContext, username: string): Promise<string | null>;
+    /**
+     * What a stored reference to a user should become, for a start-up
+     * conversion (#2041). `stored` is what a record holds today:
+     *
+     * - an `@id` (`urn:`), an orphan (`orphan:<name>`), `anonymous`, the
+     *   system principal or an empty value: `kept` (`orphan` when it is an
+     *   orphan, so the caller can count them);
+     * - a username with an account: that identity's `@id`, `converted`;
+     * - a username with no account: `orphan:<name>`, `orphaned`. The record is
+     *   then nobody's: a later account with the same name never takes it over,
+     *   and no "is it mine" check matches it.
+     *
+     * Throws when the identity store cannot answer (and so does nothing to the
+     * record): the caller postpones its whole pass to the next start, rather
+     * than orphan a name it could not look up. Ask {@link canAnswer} first.
+     */
+    convertReference(ctx: ActorContext, stored: string): Promise<{
+        value: string;
+        outcome: 'kept' | 'orphan' | 'converted' | 'orphaned';
+    }>;
+    /**
+     * Whether the identity store can answer lookups now (#2041): false when it
+     * started degraded (no provider). A start-up conversion asks this first and
+     * postpones the whole pass when it is false.
+     */
+    canAnswer(): boolean;
     private requireProvider;
     private getMetrics;
     private normalizeProviderName;

package/lib/src/managers/NotificationManager.d.ts

@@ -10,9 +10,11 @@ export interface Notification {
     title: string;
     message: string;
     level: 'info' | 'warning' | 'error' | 'success';
+    /** Who it is for, by identity `@id` (#2041); empty means every user. A name with no account is kept as given. */
     targetUsers: string[];
     createdAt: Date;
     expiresAt: Date | null;
+    /** Who dismissed it, by identity `@id` (#2041); a name with no account as given. */
     dismissedBy: string[];
 }
 /**
@@ -23,6 +25,7 @@ export interface NotificationInput {
     title?: string;
     message?: string;
     level?: 'info' | 'warning' | 'error' | 'success';
+    /** Usernames or identity `@id`s; stored as `@id`s (#2041). Empty or absent: every user. */
     targetUsers?: string[];
     expiresAt?: Date | null;
     /**
@@ -32,6 +35,8 @@ export interface NotificationInput {
      */
     escalate?: boolean;
 }
+/** A notice for administrators: the type and the audience are not the caller's to choose. */
+export type AdminNoticeInput = Omit<NotificationInput, 'type' | 'targetUsers'>;
 /**
  * Notification statistics
  */
@@ -92,6 +97,21 @@ declare class NotificationManager extends BaseManager {
      * Load notifications from storage
      */
     private loadNotifications;
+    /**
+     * Once, at start-up (#2041): every stored `targetUsers` and `dismissedBy`
+     * entry that is still a username gets `IdentityManager.convertReference`'s
+     * answer, under the system context, and the file is written once: that
+     * user's identity `@id`, or `orphan:<name>` when the name has no account
+     * (it then reaches nobody: a later account with that name is never
+     * addressed by it). `@id`s, orphans, `anonymous` and the system principal
+     * are left alone, so a second start writes nothing. Orphans are reported,
+     * counts only: a log line and the admin dashboard's needs-attention list.
+     * When the identity store cannot answer, nothing is changed and the pass is
+     * postponed to the next start, reported the same way.
+     */
+    private convertRecipientsToIdentityIds;
+    /** The identity store could not answer: nothing is converted this start, and the next start tries again (#2041). */
+    private postponeConversion;
     /**
      * Save notifications to storage
      */
@@ -115,6 +135,16 @@ declare class NotificationManager extends BaseManager {
      * @returns false when there is no such notification
      */
     updateNotificationMessage(notificationId: string, message: string): Promise<boolean>;
+    /**
+     * The one way to tell administrators something (#2040): a `system`
+     * notification targeted at the users holding `admin-system`. A notification
+     * with no targetUsers reaches every user, so no admin notice is created any
+     * other way. Nobody holds admin-system: the log line stands alone and null is
+     * returned.
+     *
+     * @returns the notification id, or null when there was nobody to tell
+     */
+    notifyAdmins(input: AdminNoticeInput): Promise<string | null>;
     /**
      * Add a notification (alias for createNotification for backward compatibility)
      * @param {NotificationInput} notification - Notification object
@@ -122,12 +152,14 @@ declare class NotificationManager extends BaseManager {
      */
     addNotification(notification: NotificationInput): Promise<string>;
     /**
-     * Get notifications for a specific user
-     * @param {string} username - Username to get notifications for
+     * The notifications for the caller: addressed to every user, or to them by
+     * identity `@id` (#2041), or by username on one with no account; never one
+     * they dismissed.
+     * @param ctx - Who is asking: the request's subject, forwarded
      * @param {boolean} includeExpired - Include expired notifications
-     * @returns {Notification[]} Array of notifications
+     * @returns Array of notifications
      */
-    getUserNotifications(username: string, includeExpired?: boolean): Notification[];
+    getUserNotifications(ctx: ActorContext, includeExpired?: boolean): Promise<Notification[]>;
     /**
      * Dismiss a notification for the caller.
      *

package/lib/src/managers/OrganizationManager.d.ts

@@ -120,9 +120,10 @@ declare class OrganizationManager extends BaseManager {
         affiliation: PersonAffiliation;
     }>>;
     /**
-     * Create an organization. `name` is required; `@id` defaults to the `url`,
-     * else a new `urn:uuid:`. `filename` is for the install anchor (seeding);
-     * other records take one from the url or name.
+     * Create an organization. `name` is required. Its `@id` is always a new
+     * `urn:uuid:` (#2041): the web address stays the ordinary `url` field, and
+     * an `@id` the caller gives is ignored. `filename` is for the install
+     * anchor (seeding); other records take one from the url or name.
      */
     create(ctx: ActorContext, org: OrganizationInput, filename?: string): Promise<Organization>;
     update(ctx: ActorContext, id: string, patch: OrganizationUpdate): Promise<Organization | null>;

package/lib/src/managers/RoleManager.d.ts

@@ -4,6 +4,8 @@ import type { Role, RoleUpdate } from '../types/Role.js';
 import type { RoleProvider } from '../types/RoleProvider.js';
 import { type ActorContext } from '../context/ActorContext.js';
 import type { JobContext } from '../context/JobContext.js';
+/** The title of the one notification for contacts found holding roles at start-up (#2040). */
+export declare const CONTACT_MEMBERS_TITLE = "Contacts are listed as role members";
 declare class RoleManager extends BaseManager {
     readonly description = "Canonical OrganizationRole records (#617 follow-up)";
     private provider;
@@ -142,6 +144,11 @@ declare class RoleManager extends BaseManager {
      * IdentityManager joins an account to an existing person, the roles the
      * account's person held go with the account. Returns how many records
      * changed. IdentityManager's join records the change. All or nothing (#2015).
+     *
+     * #2040: the roles go only with credentials. The join gives the account
+     * (`fromPersonId`'s credentials) to `toPersonId`, which is still a contact
+     * while the roles move, so the check is that `fromPersonId` is a user: a
+     * contact's memberships never move to anyone.
      */
     moveMemberships(fromPersonId: string, toPersonId: string): Promise<number>;
     /**
@@ -160,7 +167,12 @@ declare class RoleManager extends BaseManager {
      * be left without the role it was given, nor keep one it was meant to lose.
      */
     private membershipTarget;
-    /** One member change and its inverse. */
+    /**
+     * One member change and its inverse. An add is checked: the member must be a
+     * user (#2040), judged by `credentialsOf` when the credentials come from
+     * another identity in the same change (a join). An undo puts back what was
+     * there and is not checked.
+     */
     private memberChange;
     /**
      * Make each change in turn (#2015). When one fails, undo the ones made, in
@@ -175,7 +187,7 @@ declare class RoleManager extends BaseManager {
      * unless the caller sends one for a whole batch. Returns the error to throw.
      */
     private roleFailure;
-    /** An error notification for admins; a notification that cannot be sent is logged, never thrown. */
+    /** An error notification for the users holding `admin-system`; a notification that cannot be sent is logged, never thrown. */
     private reportToAdmins;
     /** #2015: the membership queue's key for one role record. */
     private membershipKey;
@@ -186,6 +198,11 @@ declare class RoleManager extends BaseManager {
      * record is created in `createIn` for an add; with no `createIn` an add to a
      * missing record throws, and a removal from one changes nothing. False,
      * writing nothing, when the person already is (or is not) a member.
+     *
+     * `mustBeUser` (#2040): the identity whose credentials an add needs, or null
+     * for an undo, which puts back what was there. Only a user holds a role; a
+     * contact is refused with {@link RoleMemberRefusal} before anything is
+     * written, the role record included.
      */
     private setMember;
     /** assignRole / removeRole: the change, recorded as a user-edit whether it happened or not (#1204, #2015). */
@@ -199,6 +216,31 @@ declare class RoleManager extends BaseManager {
      * permits is the policies, resolved at the moment of each decision.
      */
     private getOrCreateRoleRecord;
+    /**
+     * Why the identity `personId` may not hold a role, or null when it may
+     * (#2040). Only a user holds a role: an identity with credentials, whose
+     * identity record's `identifier` is the username of an account that exists.
+     * A contact's identifier is `person:<uuid>` and it has no account.
+     * Read under the system context: this is RoleManager's own rule.
+     */
+    private notAUserReason;
+    /**
+     * Check the role records for members that are contacts (#2040), once at
+     * start-up when every manager is up. Nothing is dropped or rewritten: each
+     * role holding contacts is named, with how many, in a needs-attention entry
+     * on the dashboard and a log line, and administrators get one notification
+     * (not a second while the first is still active). A contact cannot sign in,
+     * so such a membership gives nothing; an administrator decides what to do.
+     *
+     * @returns role name → how many of its members are contacts
+     */
+    reportContactMembersAtBoot(): Promise<Record<string, number>>;
+    /**
+     * One error notification for the users holding `admin-system`, unless one
+     * with this title is still active. Nobody to tell: the log line stands
+     * alone, since an empty target list would tell every user.
+     */
+    private notifyAdminsOnce;
     /** The account must exist; membership of a missing account is refused. */
     private requireAccount;
     /** #1204: a role assigned or removed is a user-edit; what the account may do changed. */

package/lib/src/providers/databaseMigrations.js

@@ -117,6 +117,20 @@ const DATABASE_MIGRATIONS = [
             db.exec('CREATE INDEX review_requests_by_status ON review_requests (status, filed_at)');
             db.exec('CREATE INDEX review_requests_by_decided ON review_requests (decided_at)');
         }
+    },
+    {
+        // #2041: a row names the owner of its resource by identity @id in
+        // `metadata.owner` and by username in `metadata.ownerUser`, so the rows
+        // about an account can still be listed after the account (and its
+        // identity record) is deleted. This column is the copy of `ownerUser`
+        // for the index; rows written before it are null, and their `owner` is
+        // the username anyway.
+        id: '20261026120000',
+        description: 'audit log: audit_events.owner_user',
+        up: (db) => {
+            db.exec('ALTER TABLE audit_events ADD COLUMN owner_user TEXT');
+            db.exec('CREATE INDEX audit_events_by_owner_user ON audit_events (owner_user, timestamp)');
+        }
     }
 ];
 export default DATABASE_MIGRATIONS;

package/lib/src/types/Comment.d.ts

@@ -1,6 +1,7 @@
 export interface PageComment {
     id: string;
     pageUuid: string;
+    /** Who wrote it: their identity `@id` (#2041); a username on a comment written before and not yet converted (a vault page's), or one with no account. */
     author: string;
     authorDisplayName: string;
     content: string;

package/lib/src/types/Organization.d.ts

@@ -5,9 +5,12 @@
  * org under `ngdpbase.application.organization.storagedir`. The install's
  * anchor org is identified by `ngdpbase.application.organization.file`.
  *
- * `@id` is the organization's canonical URL (e.g. https://example.com/),
- * NOT a synthetic urn. Use the schema.org `identifier` field for any
- * legacy slug compatibility.
+ * `@id` is a `urn:uuid:<v4>` made with the record, the organization's id for
+ * life (#2041, identity model step 6). Its web address is the ordinary `url`
+ * field, never the id. Organizations made before #2041 keep the `@id` they
+ * were given (often their URL); nothing refers to an organization by URL as
+ * its id from then on. Use the schema.org `identifier` field for any legacy
+ * slug compatibility.
  *
  * @see https://schema.org/Organization
  */
@@ -61,13 +64,13 @@ export type ContactPointEntry = ContactPoint | PostalAddress;
 export interface Organization {
     '@context': 'https://schema.org';
     '@type': 'Organization';
-    /** Canonical URL of the organization (the JSON-LD subject IRI) */
+    /** The organization's id for life: `urn:uuid:<v4>` (#2041); an organization made before #2041 keeps its own, often its URL */
     '@id': string;
     /** Human-readable name */
     name: string;
     /** Legal/registered name if different from `name` */
     legalName?: string;
-    /** Public web URL — usually the same as `@id` */
+    /** Public web address: an ordinary field, never the id (#2041) */
     url?: string;
     /** Logo URL */
     logo?: string;
@@ -87,10 +90,10 @@ export interface Organization {
     [key: string]: unknown;
 }
 /**
- * What a caller gives `OrganizationManager.create` (#1930): the fields, with
- * `@id` optional (it defaults to the `url`, else a new `urn:uuid:`).
+ * What a caller gives `OrganizationManager.create` (#1930): the fields. The
+ * `@id` is never the caller's: `create` makes a new `urn:uuid:` (#2041).
  */
-export type OrganizationInput = Partial<Organization> & {
+export type OrganizationInput = Partial<Omit<Organization, '@id'>> & {
     name: string;
 };
 /**

package/lib/src/utils/auditEvents.d.ts

@@ -126,8 +126,10 @@ export interface TokenInput extends CommonInput {
     op: TokenOp;
     /** Token id — the handle every later question about this credential uses. */
     id: string;
-    /** Whose token it is, which is not always who acted: an admin may revoke. */
+    /** Whose token it is, which is not always who acted (an admin may revoke): their identity @id (#2041), or a name with no account as given. */
     owner: string;
+    /** The token owner's username, written beside `owner` (#2041) so the rows still list after the account is deleted. */
+    ownerUser?: string;
     /** Operator-supplied label. Optional; a token need not be named. */
     name?: string | null;
     /** Only meaningful for `mint`; ignored otherwise. */
@@ -149,11 +151,14 @@ export type AttachmentDetail = {
     filename: string;
     pageName?: string | null;
     sizeBytes?: number | null;
-} | {
+}
+/** A sealed store's file: `owner` is the store owner's identity @id in the record, `ownerUser` their username beside it (#2041). */
+ | {
     attachmentId: string;
     sealedStore: {
         owner: string;
         store: string;
+        ownerUser?: string;
     };
 };
 export type AttachmentInput = CommonInput & {

package/lib/src/utils/auditEvents.js

@@ -148,7 +148,7 @@ export function buildAttachmentAuditEvent(input) {
     const { op, attachmentId, viaToken } = input;
     const who = whoOf(input);
     const metadata = 'sealedStore' in input
-        ? { attachmentId, owner: input.sealedStore.owner, store: input.sealedStore.store, sealed: true, ...tokenMetadata(viaToken), ...who.metadata }
+        ? { attachmentId, owner: input.sealedStore.owner, ...(input.sealedStore.ownerUser ? { ownerUser: input.sealedStore.ownerUser } : {}), store: input.sealedStore.store, sealed: true, ...tokenMetadata(viaToken), ...who.metadata }
         : { attachmentId, filename: input.filename, ...tokenMetadata(viaToken), ...who.metadata };
     if (!('sealedStore' in input)) {
         if (input.pageName)
@@ -273,11 +273,12 @@ export async function recordAuditEvent(sink, event, onError) {
  * every event is useless as a filter.
  */
 export function buildTokenAuditEvent(input) {
-    const { op, id, owner, name, scopes, expiresAt, previousExpiresAt, revokedBy, viaToken } = input;
+    const { op, id, owner, ownerUser, name, scopes, expiresAt, previousExpiresAt, revokedBy, viaToken } = input;
     const who = whoOf(input);
     const metadata = {
         id,
         owner,
+        ...(ownerUser ? { ownerUser } : {}),
         name: name ?? null,
         ...tokenMetadata(viaToken),
         ...who.metadata

package/lib/src/utils/username.d.ts

@@ -55,5 +55,20 @@ export declare const RESERVED_USERNAMES: readonly string[];
  * identifier can never be, or later become, someone's username.
  */
 export declare const ACCOUNTLESS_PERSON_PREFIX = "person:";
-/** True when the name belongs to a principal rather than a person, or has the account-less person prefix. */
+/**
+ * The prefix of an identity's `@id` (#2041): `urn:uuid:<v4>`, and older
+ * organizations' `urn:…` ids. No username may start with it, so a stored
+ * reference is always told apart: a value starting `urn:` is an `@id`,
+ * anything else a username not yet converted.
+ */
+export declare const IDENTITY_ID_PREFIX = "urn:";
+/**
+ * The prefix a start-up conversion gives a stored username that has no
+ * account (#2041): `orphan:<name>`. The record is then nobody's: a later
+ * account with the same name never takes it over, no "is it mine" check
+ * matches it, and only an administrator can act on it. No username may
+ * start with it.
+ */
+export declare const ORPHAN_PREFIX = "orphan:";
+/** True when the name belongs to a principal rather than a user, or has the contact, `@id` or orphan prefix. */
 export declare function isReservedUsername(username: unknown): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jwilleke/ngdpbase-types",
-  "version": "5.32.0",
+  "version": "5.34.0",
   "description": "TypeScript types for ngdpbase add-ons, and a test kit of core's own values. A dev dependency, versioned with ngdpbase.",
   "license": "Apache-2.0",
   "author": "Jim Willeke",