@manablox/db 0.3.0 → 0.4.0

package/dist/{index-Cyf_N5K3.d.ts → index-BLAkQMJT.d.ts}

@@ -1,9 +1,9 @@
-import { R as contents, S as webhooks, _ as index_d_exports, a as ContentRow, c as MembershipRow, d as PushSubscriptionRow, f as RoleRow, g as WorkflowRunRow, h as WorkflowRow, l as MenuItemRow, m as UserRow, p as SpaceRow, r as AssetVariantRow, t as AssetRow, u as MenuRow, x as webhookDeliveries, z as publishedContents } from "./index-rZ24t-Ln.js";
+import { T as webhooks, U as contents, W as publishedContents, _ as UserRow, a as ContentApprovalRow, b as index_d_exports, d as MenuItemRow, f as MenuRow, g as SpaceRow, h as RoleRow, i as AuditEntryRow, l as ContentVersionRow, m as PushSubscriptionRow, p as NotificationRow, r as AssetVariantRow, s as ContentRow, t as AssetRow, u as MembershipRow, v as WorkflowRow, w as webhookDeliveries, y as WorkflowRunRow } from "./index-DrNMGM9N.js";
 import { PostgresJsDatabase } from "drizzle-orm/postgres-js";
 import postgres from "postgres";
 import { SQL, SQL as SQL$1 } from "drizzle-orm";
 import { PgColumn, PgColumn as PgColumn$1, PgTable } from "drizzle-orm/pg-core";
-import { ContentStatus, ContentTypeDefinition, ContentTypeInput, ContentTypeRegistry, DatabaseConfig, FilterOperator, Loose, WorkflowCursor, WorkflowRunContext, WorkflowRunStatus, WorkflowSelection, WorkflowStep, WorkflowStepLog, WorkflowTrigger } from "@manablox/core";
+import { ApprovalStatus, AuditAction, AuditActor, AuditActorKind, AuditChange, AuditSortField, AuditTargetKind, ContentStatus, ContentTypeDefinition, ContentTypeInput, ContentTypeRegistry, DatabaseConfig, FilterOperator, Loose, NotificationKind, NotificationPreferences, WorkflowCursor, WorkflowRunContext, WorkflowRunStatus, WorkflowSelection, WorkflowStep, WorkflowStepLog, WorkflowTrigger } from "@manablox/core";
 //#region src/client.d.ts
 type Database = PostgresJsDatabase<typeof index_d_exports>;
 /** What `db.transaction((tx) => …)` hands its callback. */
@@ -138,6 +138,8 @@ declare class AssetRepository {
   create(data: AssetWriteData): Promise<AssetRow>;
   update(id: string, data: Loose<Pick<AssetWriteData, 'name' | 'alt' | 'title' | 'meta'>>): Promise<AssetRow>;
   delete(id: string): Promise<AssetRow | null>;
+  /** Timestamps an import carries over; `create()` can only stamp the moment of import. */
+  restoreTimestamps(id: string, createdAt: Date, updatedAt: Date): Promise<void>;
   variants(assetIds: string[]): Promise<AssetVariantRow[]>;
   findVariant(assetId: string, preset: string, format: string): Promise<AssetVariantRow | null>;
   /** Drops every variant row; the caller removes the files. */
@@ -206,6 +208,92 @@ declare class AssetUsageRepository {
   }>>;
 }
 //#endregion
+//#region src/repositories/audit.d.ts
+interface AuditAppendInput {
+  /** The space the action concerns; omit for an instance-wide action. */
+  spaceId?: string | null | undefined;
+  /** Who did it; the current actor (see `runAsActor`) when omitted. */
+  actor?: AuditActor | undefined;
+  action: AuditAction;
+  targetKind: AuditTargetKind;
+  targetId?: string | null | undefined;
+  targetLabel?: string | null | undefined;
+  changes?: AuditChange[] | undefined;
+  meta?: Record<string, unknown> | null | undefined;
+  at?: Date | undefined;
+}
+interface AuditFilter {
+  /** A space's entries; `null` for instance-wide entries only; absent for every entry. */
+  spaceId?: string | null | undefined;
+  actorKind?: AuditActorKind | undefined;
+  actorId?: string | undefined;
+  actions?: AuditAction[] | undefined;
+  targetKind?: AuditTargetKind | undefined;
+  targetId?: string | undefined;
+  from?: Date | undefined;
+  to?: Date | undefined;
+  /** Matched against the actor's label, the target's label and the action. */
+  search?: string | undefined;
+}
+interface AuditSort {
+  by: AuditSortField;
+  direction: 'asc' | 'desc';
+}
+/** The outcome of walking the chain: where it broke, if it did. */
+interface AuditVerification {
+  ok: boolean;
+  checked: number;
+  /** The first entry whose hash does not match, or whose `prevHash` is not its predecessor's. */
+  brokenAt: {
+    seq: number;
+    id: string;
+    reason: 'hash' | 'link';
+  } | null;
+}
+interface AuditRepositoryOptions {
+  /** Told when `record` could not write; the action itself is not undone. */
+  onError?: ((error: unknown, input: AuditAppendInput) => void) | undefined;
+  /**
+   * Told after every entry has been committed: the realtime feed listens here, because
+   * an audit entry is written for every change and only after it has happened. A
+   * listener that throws is reported to `onError`; the entry stays written.
+   */
+  onAppended?: ((row: AuditEntryRow) => void) | undefined;
+}
+/**
+ * Appends to and reads the audit log. There is no update and no delete: the table
+ * refuses both, so this class offers neither.
+ */
+declare class AuditRepository {
+  private readonly db;
+  private readonly options;
+  constructor(db: Database, options?: AuditRepositoryOptions);
+  /**
+   * Writes one entry, chained to the last. Writers are serialised on a transaction-level
+   * advisory lock, so two entries can never both claim the same predecessor; the lock
+   * is held for one read and one insert.
+   */
+  append(input: AuditAppendInput): Promise<AuditEntryRow>;
+  private write;
+  /**
+   * `append` that never throws. The write it describes has already happened; failing
+   * the request now would report an error for something that succeeded, so the failure
+   * is reported to `onError` (the host logs it) and the caller carries on.
+   */
+  record(input: AuditAppendInput): Promise<AuditEntryRow | null>;
+  findById(id: string): Promise<AuditEntryRow | null>;
+  list(filter: AuditFilter, sort?: AuditSort, pagination?: Pagination): Promise<Paginated<AuditEntryRow>>;
+  /** The entries about one thing, oldest first: a document's history. */
+  forTarget(targetKind: AuditTargetKind, targetId: string, limit?: number): Promise<AuditEntryRow[]>;
+  /**
+   * Recomputes every hash from the first entry on and checks each link to its
+   * predecessor. The chain is one across the instance, so this walks all of it, in
+   * batches; on a large log it takes a while and that is the point.
+   */
+  verify(batchSize?: number): Promise<AuditVerification>;
+  count(filter?: AuditFilter): Promise<number>;
+}
+//#endregion
 //#region src/repositories/content.d.ts
 interface ContentWriteData {
   id?: string | undefined;
@@ -328,6 +416,25 @@ declare class ContentRepository {
   }>>;
   /** The row exactly as it was at that version — `snapshot()` stores the whole row. */
   versionSnapshot(contentId: string, version: number): Promise<ContentRow | null>;
+  /** Every stored version of these documents, oldest first, for a space export. */
+  history(contentIds: string[]): Promise<ContentVersionRow[]>;
+  /**
+   * Puts an imported document back the way its source had it: the version counter and
+   * timestamps `create()` had to invent, and the version history in place of the single
+   * snapshot `create()` wrote. The row's own columns are left alone otherwise.
+   */
+  restoreHistory(id: string, data: {
+    version: number;
+    createdAt: Date;
+    updatedAt: Date;
+    versions: Array<{
+      version: number;
+      label: string | null;
+      snapshot: Record<string, unknown>;
+      createdAt: Date;
+      createdBy: string | null;
+    }>;
+  }): Promise<void>;
   private snapshot;
   private findRow;
   private lockRow;
@@ -340,6 +447,55 @@ declare function buildTree(rows: Array<ContentRow & {
   depth: number;
 }>, rootId: string | null): TreeNode[];
 //#endregion
+//#region src/repositories/content-approval.d.ts
+interface ApprovalRequestData {
+  spaceId: string;
+  contentId: string;
+  typeId: string;
+  requestedBy: string | null;
+  requestedByLabel: string;
+  requestNote?: string | null | undefined;
+  contentVersion?: number | null | undefined;
+}
+interface ApprovalDecisionData {
+  status: Exclude<ApprovalStatus, 'pending'>;
+  decidedBy: string | null;
+  decidedByLabel: string | null;
+  decisionNote?: string | null | undefined;
+}
+/** A pending request with the document it concerns, for the reviewers' queue. */
+interface PendingApproval extends ContentApprovalRow {
+  content: {
+    id: string;
+    title: string;
+    locale: string;
+    typeId: string;
+    updatedAt: Date;
+  };
+}
+/**
+ * The approval history of documents. Rows are appended when someone asks and closed
+ * when someone decides; the "one pending per document" rule is the service's, this
+ * only offers the reads it needs to keep it.
+ */
+declare class ContentApprovalRepository {
+  private readonly db;
+  constructor(db: Database);
+  findById(id: string): Promise<ContentApprovalRow | null>;
+  /** The open request on a document, if there is one. */
+  pendingFor(contentId: string): Promise<ContentApprovalRow | null>;
+  /** The most recent request on a document, whatever became of it. */
+  latestFor(contentId: string): Promise<ContentApprovalRow | null>;
+  historyFor(contentId: string, limit?: number): Promise<ContentApprovalRow[]>;
+  /**
+   * Every open request in a space, oldest first, with the document beside it. Narrowed
+   * to `typeIds` when the reader may only publish some types; `null` means every type.
+   */
+  pendingInSpace(spaceId: string, typeIds?: string[] | null): Promise<PendingApproval[]>;
+  request(data: ApprovalRequestData): Promise<ContentApprovalRow>;
+  decide(id: string, data: ApprovalDecisionData): Promise<ContentApprovalRow>;
+}
+//#endregion
 //#region src/repositories/content-type.d.ts
 /**
  * Persistence for *runtime-defined* content types only. Code-defined types come from
@@ -420,8 +576,49 @@ declare class MenuRepository {
   resolve(menu: MenuRow, locale: string, published?: boolean): Promise<ResolvedMenuItem[]>;
 }
 //#endregion
+//#region src/repositories/notification.d.ts
+interface NotificationInsert {
+  userId: string;
+  spaceId?: string | null | undefined;
+  kind: NotificationKind;
+  title: string;
+  body?: string | undefined;
+  url?: string | null | undefined;
+  targetKind?: string | null | undefined;
+  targetId?: string | null | undefined;
+  actorId?: string | null | undefined;
+  actorLabel?: string | null | undefined;
+  meta?: Record<string, unknown> | null | undefined;
+}
+interface NotificationFilter {
+  unreadOnly?: boolean | undefined;
+  kinds?: NotificationKind[] | undefined;
+  spaceId?: string | null | undefined;
+}
+/**
+ * One person's inbox. Every method is scoped to a `userId`, so a row id from another
+ * account is inert: there is no way to read or change what is not yours.
+ */
+declare class NotificationRepository {
+  private readonly db;
+  constructor(db: Database);
+  /** Inserts one row per recipient in one statement; an empty list writes nothing. */
+  insertMany(rows: NotificationInsert[]): Promise<NotificationRow[]>;
+  list(userId: string, filter?: NotificationFilter, pagination?: Pagination): Promise<Paginated<NotificationRow>>;
+  findById(userId: string, id: string): Promise<NotificationRow | null>;
+  countUnread(userId: string): Promise<number>;
+  /** Marks the named rows read; rows already read keep their original time. Returns how many changed. */
+  markRead(userId: string, ids: string[]): Promise<number>;
+  markUnread(userId: string, ids: string[]): Promise<number>;
+  markAllRead(userId: string): Promise<number>;
+  delete(userId: string, ids: string[]): Promise<number>;
+  deleteRead(userId: string): Promise<number>;
+}
+//#endregion
 //#region src/repositories/role.d.ts
 interface RoleWriteData {
+  /** Kept when given, so an import can restore a role under the id its memberships name. */
+  id?: string | undefined;
   name: string;
   machineName: string;
   description?: string | null;
@@ -489,6 +686,8 @@ declare class UserRepository {
   constructor(db: Database);
   findById(id: string): Promise<UserRow | null>;
   findManyByIds(ids: string[]): Promise<UserRow[]>;
+  /** Every account holding an instance role, for a fan-out to the superadmins. */
+  findByRole(role: string): Promise<UserRow[]>;
   findByEmail(email: string): Promise<UserRow | null>;
   list(pagination: Pagination, search?: string): Promise<Paginated<UserRow>>;
   /**
@@ -515,6 +714,9 @@ declare class UserRepository {
   /** Signs the user out everywhere. */
   revokeSessions(userId: string): Promise<void>;
   countByRole(role: string): Promise<number>;
+  setNotificationPreferences(id: string, preferences: NotificationPreferences): Promise<UserRow>;
+  /** The stored hash of the password credential, or `null` for an account without one. */
+  passwordHash(userId: string): Promise<string | null>;
   setRole(id: string, role: string): Promise<UserRow>;
   /**
    * Authoritative role plus space memberships in one query.
@@ -548,6 +750,15 @@ declare class UserRepository {
 //#region src/repositories/webhook.d.ts
 type WebhookRow = typeof webhooks.$inferSelect;
 type WebhookDeliveryRow = typeof webhookDeliveries.$inferSelect;
+interface WebhookWriteData {
+  id?: string | undefined;
+  spaceId: string;
+  name: string;
+  url: string;
+  secret?: string | null | undefined;
+  events: string[];
+  enabled?: boolean | undefined;
+}
 interface WebhookDeliveryData {
   webhookId: string;
   event: string;
@@ -560,6 +771,8 @@ declare class WebhookRepository {
   private readonly db;
   constructor(db: Database);
   findById(id: string): Promise<WebhookRow | null>;
+  listBySpace(spaceId: string): Promise<WebhookRow[]>;
+  create(data: WebhookWriteData): Promise<WebhookRow>;
   /** The switched-on webhooks of a space, for fanning an event out. */
   findEnabled(spaceId: string): Promise<WebhookRow[]>;
   recordDelivery(data: WebhookDeliveryData): Promise<WebhookDeliveryRow>;
@@ -652,7 +865,13 @@ interface Repositories {
   roles: RoleRepository;
   workflows: WorkflowRepository;
   webhooks: WebhookRepository;
+  audit: AuditRepository;
+  notifications: NotificationRepository;
+  approvals: ContentApprovalRepository;
+}
+interface RepositoriesOptions {
+  audit?: AuditRepositoryOptions | undefined;
 }
-declare function createRepositories(db: Database, registry: ContentTypeRegistry): Repositories;
+declare function createRepositories(db: Database, registry: ContentTypeRegistry, options?: RepositoriesOptions): Repositories;
 //#endregion
-export { AssetRepository as A, buildContentWhere as B, ContentRepository as C, buildTree as D, TreeNode as E, ContentSort as F, Executor as G, Database as H, ContentTable as I, createDatabase as J, Sql as K, FieldFilter as L, Paginated as M, paginate as N, AssetUsageRepository as O, ContentFilter as P, Pagination as R, ContentTypeRepository as S, SQL$1 as T, DatabaseHandle as U, buildOrderBy as V, DatabaseOptions as W, MenuItemInput as _, WorkflowRunCreateData as a, MenuWriteData as b, WebhookDeliveryRow as c, SpaceRole as d, UserCreateData as f, SpaceWriteData as g, SpaceRepository as h, WorkflowRepository as i, AssetWriteData as j, AssetFilter as k, WebhookRepository as l, UserUpdateData as m, createRepositories as n, WorkflowWriteData as o, UserRepository as p, Transaction as q, RUNS_KEPT_PER_WORKFLOW as r, WebhookDeliveryData as s, Repositories as t, WebhookRow as u, MenuItemNode as v, ContentWriteData as w, ResolvedMenuItem as x, MenuRepository as y, PgColumn$1 as z };
+export { Pagination as $, ContentApprovalRepository as A, AuditRepositoryOptions as B, MenuItemNode as C, ContentTypeRepository as D, ResolvedMenuItem as E, TreeNode as F, AssetRepository as G, AuditVerification as H, buildTree as I, paginate as J, AssetWriteData as K, AuditAppendInput as L, ContentRepository as M, ContentWriteData as N, ApprovalDecisionData as O, SQL$1 as P, FieldFilter as Q, AuditFilter as R, MenuItemInput as S, MenuWriteData as T, AssetUsageRepository as U, AuditSort as V, AssetFilter as W, ContentSort as X, ContentFilter as Y, ContentTable as Z, SpaceRepository as _, WorkflowRepository as a, DatabaseOptions as at, NotificationInsert as b, WebhookDeliveryData as c, Transaction as ct, WebhookRow as d, PgColumn$1 as et, WebhookWriteData as f, UserUpdateData as g, UserRepository as h, RUNS_KEPT_PER_WORKFLOW as i, DatabaseHandle as it, PendingApproval as j, ApprovalRequestData as k, WebhookDeliveryRow as l, createDatabase as lt, UserCreateData as m, RepositoriesOptions as n, buildOrderBy as nt, WorkflowRunCreateData as o, Executor as ot, SpaceRole as p, Paginated as q, createRepositories as r, Database as rt, WorkflowWriteData as s, Sql as st, Repositories as t, buildContentWhere as tt, WebhookRepository as u, SpaceWriteData as v, MenuRepository as w, NotificationRepository as x, NotificationFilter as y, AuditRepository as z };