@bevel-software/platform-core-backend 0.30.0 → 0.32.0

package/src/shared/git.contract.ts

@@ -248,6 +248,16 @@ export function isGitTimeout(err: unknown): boolean {
   return err instanceof GitRunError && err.timedOut;
 }
 
+/**
+ * A full object id (SHA-1 or SHA-256, lowercase hex): what every at-ref
+ * access gate resolves its ref to before reading, and the one spelling the
+ * history tools accept for a commit — anything shorter or mixed-case is a
+ * name, which a fetch can move.
+ */
+export function isCommitSha(ref: string): boolean {
+  return /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(ref);
+}
+
 /**
  * Runs one git command to completion and returns what it wrote.
  *

package/src/shared/listener-seam.ts

@@ -0,0 +1,52 @@
+import type { ILogger } from './logger.contract.js';
+
+/**
+ * A listener answers how it reached the people an event concerns — a
+ * non-empty channel name, `'email'` say — or null when it did not (nothing
+ * configured, nobody to tell, the send failed). It is awaited: the caller's
+ * answer says who was notified, truthfully, so a listener bounds its own
+ * wait. A throw is logged and counts as null; it never fails the caller. An
+ * empty name is no channel and counts as null too.
+ */
+export type NotifyingListener<E> = (event: E) => Promise<string | null>;
+
+/**
+ * The one way core runs the notification listeners a deployment registers
+ * on a seam (an account invited, a change request opened): every listener
+ * in registration order, each awaited, the channels that reached somebody
+ * collected in that order, a failure logged and counted as "did not" so the
+ * event's own effect — the account made, the request opened — stands
+ * whatever the listeners do. A seam wraps one of these per event and keeps
+ * its own typed registration method, so the rule above is written once.
+ */
+export class ListenerSeam<E> {
+  private readonly listeners: NotifyingListener<E>[] = [];
+
+  /**
+   * @param log Where a failed listener is reported.
+   * @param failed The line logged for one, said in the seam's own terms
+   *   ("an account-invited listener failed; the person was not notified by it:").
+   */
+  constructor(
+    private readonly log: ILogger,
+    private readonly failed: string,
+  ) {}
+
+  add(listener: NotifyingListener<E>): void {
+    this.listeners.push(listener);
+  }
+
+  /** Run every listener in registration order; the channels that reached somebody, in that order. */
+  async run(event: E): Promise<string[]> {
+    const notified: string[] = [];
+    for (const listener of this.listeners) {
+      try {
+        const channel = await listener(event);
+        if (channel !== null && channel !== '') notified.push(channel);
+      } catch (err) {
+        this.log.error(this.failed, { err });
+      }
+    }
+    return notified;
+  }
+}

package/src/shared/no-link-below.ts

@@ -0,0 +1,29 @@
+import path from 'node:path';
+import { lstatOrNull } from './rename-no-replace.js';
+
+/**
+ * The first folder between `base` (exclusive) and `absolute` (inclusive)
+ * that is a symbolic link, or null when none is — judged by `lstat` on each
+ * ancestor, so a path that would be followed out of `base` is named before
+ * anything reads or writes through it. ONE rule for every sink that resolves
+ * a repository path on disk: the locking filesystem's moves and the merge's
+ * conflict reads and writes.
+ */
+export async function linkedAncestor(base: string, absolute: string): Promise<string | null> {
+  const root = path.resolve(base);
+  // Below `root` means past a separator after it: `/tmp/repository` is a
+  // sibling of `/tmp/repo`, not inside it, and is never walked or stat'ed. A
+  // filesystem root already ends with its separator.
+  const inside = root.endsWith(path.sep) ? root : root + path.sep;
+  let current = path.resolve(absolute);
+  const ancestors: string[] = [];
+  while (current.startsWith(inside)) {
+    ancestors.push(current);
+    current = path.dirname(current);
+  }
+  for (const ancestor of ancestors) {
+    const stat = await lstatOrNull(ancestor);
+    if (stat?.isSymbolicLink()) return ancestor;
+  }
+  return null;
+}