@terrafirmagreg-team/data 1.2.1 → 1.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@terrafirmagreg-team/data",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "type": "module",
   "description": "Storage drivers and shared helpers",
   "license": "LGPL-3.0-only",

package/src/lib/app-token.ts

@@ -1,16 +1,17 @@
+import { createPrivateKey, sign } from 'node:crypto';
 import { env } from './env';
 import { githubFetch } from './github';
 
 const TOKEN_TTL_MS = 50 * 60 * 1000;
 const cache = new Map<string, { token: Promise<string>; exp: number }>();
 
-function pemToDer(pem: string): ArrayBuffer {
-  const b64 = pem.replace(/\\n/g, '\n').replace(/-----(?:BEGIN|END)[^\n-]*-----|\s/g, '');
-  const bin = Buffer.from(b64, 'base64');
-  return bin.buffer.slice(
-    bin.byteOffset,
-    bin.byteOffset + bin.byteLength,
-  ) as ArrayBuffer;
+function privateKey(pem: string) {
+  const normalized = pem.replace(/\\n/g, '\n');
+  if (normalized.includes('-----BEGIN')) return createPrivateKey(normalized);
+  return createPrivateKey({
+    key: Buffer.from(normalized.trim(), 'base64'),
+    format: 'der',
+  });
 }
 
 async function appJwt(): Promise<string> {
@@ -22,19 +23,8 @@ async function appJwt(): Promise<string> {
   const pack = (value: object) =>
     Buffer.from(JSON.stringify(value)).toString('base64url');
   const payload = `${pack({ alg: 'RS256', typ: 'JWT' })}.${pack({ iat: now - 60, exp: now + 540, iss: appId })}`;
-  const key = await crypto.subtle.importKey(
-    'pkcs8',
-    pemToDer(pem),
-    { name: 'RSASSA-PKCS1-v1_5', hash: 'SHA-256' },
-    false,
-    ['sign'],
-  );
-  const signature = await crypto.subtle.sign(
-    'RSASSA-PKCS1-v1_5',
-    key,
-    new TextEncoder().encode(payload),
-  );
-  return `${payload}.${Buffer.from(signature).toString('base64url')}`;
+  const signature = sign('sha256', Buffer.from(payload), privateKey(pem));
+  return `${payload}.${signature.toString('base64url')}`;
 }
 
 async function mintInstallationToken(repo: string): Promise<string> {

package/src/lib/dump-status.ts

@@ -0,0 +1,91 @@
+export type DumpDatasetState = {
+  status: 'ok' | 'failed';
+  fails: number;
+  lastFail: number;
+};
+
+export type DumpStatusSnapshot = {
+  statuses: Record<string, DumpDatasetState>;
+  retryNonce: number;
+  dismissed: boolean;
+};
+
+type Store = {
+  state: Map<string, DumpDatasetState>;
+  listeners: Set<() => void>;
+  retryNonce: number;
+  dismissedSignature: string;
+  snapshot: DumpStatusSnapshot;
+};
+
+const store = ((globalThis as Record<symbol, unknown>)[
+  Symbol.for('terrafirmagreg.dump-status')
+] ??= {
+  state: new Map(),
+  listeners: new Set(),
+  retryNonce: 0,
+  dismissedSignature: '',
+  snapshot: { statuses: {}, retryNonce: 0, dismissed: false },
+}) as Store;
+
+function notify() {
+  store.snapshot = {
+    statuses: Object.fromEntries(store.state),
+    retryNonce: store.retryNonce,
+    dismissed: dumpFailuresDismissed(),
+  };
+  for (const listener of store.listeners) listener();
+}
+
+export function markDumpResult(id: string, ok: boolean) {
+  const prev = store.state.get(id);
+  if (ok) {
+    if (!prev || prev.status === 'failed') {
+      store.state.set(id, { status: 'ok', fails: 0, lastFail: 0 });
+      if (prev?.status === 'failed') store.retryNonce += 1;
+      notify();
+    }
+    return;
+  }
+  const fails = (prev?.fails ?? 0) + 1;
+  store.state.set(id, { status: 'failed', fails, lastFail: Date.now() });
+  notify();
+}
+
+export function dumpStatusSnapshot(): DumpStatusSnapshot {
+  return store.snapshot;
+}
+
+export function subscribeDumpStatus(listener: () => void): () => void {
+  store.listeners.add(listener);
+  return () => store.listeners.delete(listener);
+}
+
+export function requestDumpRetry() {
+  store.retryNonce += 1;
+  notify();
+}
+
+export function dumpRetryDelay(fails: number): number {
+  return fails <= 1 ? 10_000 : fails === 2 ? 30_000 : 60_000;
+}
+
+export function dumpFailureSignature(): string {
+  const failed = [...store.state.entries()].filter(
+    ([, state]) => state.status === 'failed',
+  );
+  if (!failed.length) return '';
+  const ids = failed.map(([id]) => id).sort().join(',');
+  const fails = failed.reduce((sum, [, state]) => sum + state.fails, 0);
+  return `${ids}#${fails}`;
+}
+
+export function dismissDumpFailures() {
+  store.dismissedSignature = dumpFailureSignature();
+  notify();
+}
+
+export function dumpFailuresDismissed(): boolean {
+  const signature = dumpFailureSignature();
+  return signature !== '' && signature === store.dismissedSignature;
+}