hazo_admin 0.3.2 → 0.6.0

package/dist/issues/store.js

@@ -0,0 +1,401 @@
+import 'server-only';
+import { createLogger } from 'hazo_core';
+const log = createLogger('hazo_admin:issues');
+const TABLE = 'hazo_admin_issues';
+export function toIssueRecord(raw) {
+    return {
+        id: raw.id,
+        scope_id: raw.scope_id,
+        type: raw.type,
+        status: raw.status,
+        subject_user_id: raw.subject_user_id,
+        assigned_to: raw.assigned_to ?? null,
+        recipient_scope_id: raw.recipient_scope_id ?? null,
+        title: raw.title,
+        summary: raw.summary,
+        payload: typeof raw.payload === 'string'
+            ? JSON.parse(raw.payload)
+            : raw.payload ?? {},
+        dedupe_key: raw.dedupe_key,
+        occurrence_count: raw.occurrence_count,
+        first_seen_at: raw.first_seen_at,
+        last_seen_at: raw.last_seen_at,
+        resolution: raw.resolution ?? null,
+        resolution_role_id: raw.resolution_role_id ?? null,
+        resolution_reason: raw.resolution_reason ?? null,
+        resolved_by: raw.resolved_by ?? null,
+        resolved_at: raw.resolved_at ?? null,
+        created_at: raw.created_at,
+        updated_at: raw.updated_at,
+    };
+}
+/**
+ * Legal status transitions:
+ *   new  → wip
+ *   new  → closed   (direct close)
+ *   wip  → closed
+ *   any  → archived (only via archiveClosedOlderThan)
+ */
+const ALLOWED_TRANSITIONS = {
+    new: ['wip', 'closed'],
+    wip: ['closed'],
+    closed: [],
+    archived: [],
+};
+function assertTransition(from, to) {
+    const allowed = ALLOWED_TRANSITIONS[from] ?? [];
+    if (!allowed.includes(to)) {
+        throw new Error(`hazo_admin:issues — illegal status transition: ${from} → ${to}`);
+    }
+}
+export function createIssueStore(adapter) {
+    function now() {
+        return new Date().toISOString();
+    }
+    async function raw(sql, params = []) {
+        return adapter.raw(sql, params);
+    }
+    async function createOrBumpIssue(input) {
+        log.debug('createOrBumpIssue', { dedupe_key: input.dedupe_key });
+        // Check for an existing open issue with this dedupe_key.
+        const existing = await raw(`SELECT * FROM ${TABLE} WHERE dedupe_key = $1 AND status NOT IN ('closed', 'archived') LIMIT 1`, [input.dedupe_key]);
+        if (existing && existing.length > 0) {
+            const ts = now();
+            const bumped = await raw(`UPDATE ${TABLE}
+         SET occurrence_count = occurrence_count + 1,
+             last_seen_at = $1,
+             updated_at = $2
+         WHERE id = $3
+         RETURNING *`, [ts, ts, existing[0].id]);
+            const row = (bumped && bumped.length > 0 ? bumped[0] : existing[0]);
+            return { issue: toIssueRecord(row), isNew: false };
+        }
+        const ts = now();
+        const id = crypto.randomUUID();
+        const payloadStr = JSON.stringify(input.payload);
+        const inserted = await raw(`INSERT INTO ${TABLE} (
+        id, scope_id, type, status, subject_user_id, assigned_to,
+        recipient_scope_id, title, summary, payload, dedupe_key,
+        occurrence_count, first_seen_at, last_seen_at,
+        resolution, resolution_role_id, resolution_reason,
+        resolved_by, resolved_at, created_at, updated_at
+      ) VALUES (
+        $1, $2, $3, 'new', $4, NULL,
+        $5, $6, $7, $8, $9,
+        1, $10, $11,
+        NULL, NULL, NULL,
+        NULL, NULL, $12, $13
+      ) RETURNING *`, [
+            id,
+            input.scope_id,
+            input.type,
+            input.subject_user_id,
+            input.recipient_scope_id ?? null,
+            input.title,
+            input.summary,
+            payloadStr,
+            input.dedupe_key,
+            ts,
+            ts,
+            ts,
+            ts,
+        ]);
+        const row = (inserted && inserted.length > 0 ? inserted[0] : null);
+        if (!row) {
+            throw new Error('hazo_admin:issues — INSERT returned no row');
+        }
+        return { issue: toIssueRecord(row), isNew: true };
+    }
+    async function listIssues(opts) {
+        const { adminScopeIds, isGlobalAdmin = false, status, assignedTo, type, limit = 50, offset = 0, } = opts;
+        if (!isGlobalAdmin && (!adminScopeIds || adminScopeIds.length === 0)) {
+            return [];
+        }
+        const conditions = [];
+        const params = [];
+        let paramIdx = 1;
+        if (!isGlobalAdmin && adminScopeIds && adminScopeIds.length > 0) {
+            const placeholders = adminScopeIds.map(() => `$${paramIdx++}`).join(', ');
+            conditions.push(`scope_id IN (${placeholders})`);
+            params.push(...adminScopeIds);
+        }
+        if (status !== undefined) {
+            const statuses = Array.isArray(status) ? status : [status];
+            const placeholders = statuses.map(() => `$${paramIdx++}`).join(', ');
+            conditions.push(`status IN (${placeholders})`);
+            params.push(...statuses);
+        }
+        if (assignedTo !== undefined) {
+            if (assignedTo === null) {
+                conditions.push('assigned_to IS NULL');
+            }
+            else {
+                conditions.push(`assigned_to = $${paramIdx++}`);
+                params.push(assignedTo);
+            }
+        }
+        if (type !== undefined) {
+            conditions.push(`type = $${paramIdx++}`);
+            params.push(type);
+        }
+        const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+        params.push(limit);
+        params.push(offset);
+        const sql = `SELECT * FROM ${TABLE} ${where} ORDER BY last_seen_at DESC LIMIT $${paramIdx++} OFFSET $${paramIdx++}`;
+        const rows = await raw(sql, params);
+        return (rows ?? []).map(toIssueRecord);
+    }
+    async function getIssue(id) {
+        const rows = await raw(`SELECT * FROM ${TABLE} WHERE id = $1 LIMIT 1`, [id]);
+        if (!rows || rows.length === 0)
+            return null;
+        return toIssueRecord(rows[0]);
+    }
+    async function transitionStatus(id, status, actorUserId) {
+        const issue = await getIssue(id);
+        if (!issue)
+            throw new Error(`hazo_admin:issues — issue ${id} not found`);
+        assertTransition(issue.status, status);
+        const ts = now();
+        const patch = { status, updated_at: ts };
+        // On →wip: auto-assign to actor if not yet assigned.
+        if (status === 'wip' && issue.assigned_to === null) {
+            patch.assigned_to = actorUserId;
+        }
+        const setClauses = Object.keys(patch)
+            .map((k, i) => `${k} = $${i + 2}`)
+            .join(', ');
+        const updated = await raw(`UPDATE ${TABLE} SET ${setClauses} WHERE id = $1 RETURNING *`, [id, ...Object.values(patch)]);
+        const row = updated && updated.length > 0 ? updated[0] : null;
+        if (!row)
+            throw new Error(`hazo_admin:issues — UPDATE returned no row for ${id}`);
+        return toIssueRecord(row);
+    }
+    async function setAssignee(id, userId) {
+        const ts = now();
+        const updated = await raw(`UPDATE ${TABLE} SET assigned_to = $1, updated_at = $2 WHERE id = $3 RETURNING *`, [userId, ts, id]);
+        const row = updated && updated.length > 0 ? updated[0] : null;
+        if (!row)
+            throw new Error(`hazo_admin:issues — issue ${id} not found`);
+        return toIssueRecord(row);
+    }
+    async function resolveIssue(id, opts) {
+        const ts = now();
+        const updated = await raw(`UPDATE ${TABLE}
+       SET status = 'closed',
+           resolution = $1,
+           resolution_role_id = $2,
+           resolution_reason = $3,
+           resolved_by = $4,
+           resolved_at = $5,
+           updated_at = $6
+       WHERE id = $7
+       RETURNING *`, [
+            opts.resolution,
+            opts.role_id ?? null,
+            opts.reason ?? null,
+            opts.resolved_by,
+            ts,
+            ts,
+            id,
+        ]);
+        const row = updated && updated.length > 0 ? updated[0] : null;
+        if (!row)
+            throw new Error(`hazo_admin:issues — issue ${id} not found`);
+        return toIssueRecord(row);
+    }
+    async function archiveClosedOlderThan(cutoffDate) {
+        const cutoff = cutoffDate.toISOString();
+        log.debug('archiveClosedOlderThan', { cutoff });
+        const result = await raw(`UPDATE ${TABLE}
+       SET status = 'archived', updated_at = $1
+       WHERE status = 'closed' AND resolved_at < $2
+       RETURNING id`, [now(), cutoff]);
+        const count = result ? result.length : 0;
+        log.debug('archiveClosedOlderThan: archived', { count });
+        return count;
+    }
+    return {
+        createOrBumpIssue,
+        listIssues,
+        getIssue,
+        transitionStatus,
+        setAssignee,
+        resolveIssue,
+        archiveClosedOlderThan,
+    };
+}
+/**
+ * PostgREST-native implementation of IssueStore.
+ * Uses createCrudService + adapter.claimRows so no raw SQL is issued.
+ * Falls back to createIssueStore when the adapter exposes a raw() method
+ * (i.e. it is a direct-DB adapter that already handles SQL).
+ *
+ * Returns a Promise because it lazily imports hazo_connect/server on the
+ * CRUD path (avoiding loading the full hazo_connect stack for raw adapters).
+ */
+export async function createIssueStoreFromConnect(adapter) {
+    // Capability sniff: direct-DB adapters have a raw() method — use the raw store.
+    if (typeof adapter.raw === 'function') {
+        return createIssueStore(adapter);
+    }
+    // Lazy import to avoid pulling hazo_connect into server-only environments
+    // that don't have it installed (e.g., direct-SQL test adapters).
+    const { createCrudService } = await import('hazo_connect/server');
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const crud = createCrudService(adapter, TABLE);
+    function now() {
+        return new Date().toISOString();
+    }
+    async function createOrBumpIssue(input) {
+        log.debug('createIssueStoreFromConnect:createOrBumpIssue', { dedupe_key: input.dedupe_key });
+        // Atomically bump an existing open issue via claimRows.
+        const bumped = await adapter.claimRows({
+            table: TABLE,
+            where: {
+                dedupe_key: input.dedupe_key,
+                status: { in: ['new', 'wip'] },
+            },
+            set: {
+                occurrence_count: { increment: 1 },
+                last_seen_at: { $now: true },
+                updated_at: { $now: true },
+            },
+            returning: ['*'],
+        });
+        if (bumped && bumped.length > 0) {
+            return { issue: toIssueRecord(bumped[0]), isNew: false };
+        }
+        // No open issue found — insert a new one.
+        const ts = now();
+        const inserted = await crud.insert({
+            scope_id: input.scope_id,
+            type: input.type,
+            status: 'new',
+            subject_user_id: input.subject_user_id,
+            assigned_to: null,
+            recipient_scope_id: input.recipient_scope_id ?? null,
+            title: input.title,
+            summary: input.summary,
+            payload: input.payload,
+            dedupe_key: input.dedupe_key,
+            occurrence_count: 1,
+            first_seen_at: ts,
+            last_seen_at: ts,
+            resolution: null,
+            resolution_role_id: null,
+            resolution_reason: null,
+            resolved_by: null,
+            resolved_at: null,
+            created_at: ts,
+            updated_at: ts,
+        });
+        const row = Array.isArray(inserted) ? inserted[0] : inserted;
+        if (!row)
+            throw new Error('hazo_admin:issues — INSERT returned no row');
+        return { issue: toIssueRecord(row), isNew: true };
+    }
+    async function listIssues(opts) {
+        const { adminScopeIds, isGlobalAdmin = false, status, assignedTo, type, limit = 50, offset = 0, } = opts;
+        if (!isGlobalAdmin && (!adminScopeIds || adminScopeIds.length === 0)) {
+            return [];
+        }
+        const qb = crud.query();
+        if (!isGlobalAdmin && adminScopeIds && adminScopeIds.length > 0) {
+            qb.where('scope_id', 'in', adminScopeIds);
+        }
+        if (status !== undefined) {
+            const statuses = Array.isArray(status) ? status : [status];
+            qb.where('status', 'in', statuses);
+        }
+        if (assignedTo !== undefined) {
+            if (assignedTo === null) {
+                qb.where('assigned_to', 'is', null);
+            }
+            else {
+                qb.where('assigned_to', 'eq', assignedTo);
+            }
+        }
+        if (type !== undefined) {
+            qb.where('type', 'eq', type);
+        }
+        qb.order('last_seen_at', 'desc').limit(limit).offset(offset);
+        const rows = await qb.execute('GET');
+        return (Array.isArray(rows) ? rows : []).map((r) => toIssueRecord(r));
+    }
+    async function getIssue(id) {
+        const row = await crud.findById(id);
+        if (!row)
+            return null;
+        return toIssueRecord(row);
+    }
+    async function transitionStatus(id, status, actorUserId) {
+        const issue = await getIssue(id);
+        if (!issue)
+            throw new Error(`hazo_admin:issues — issue ${id} not found`);
+        assertTransition(issue.status, status);
+        const ts = now();
+        const patch = { status, updated_at: ts };
+        if (status === 'wip' && issue.assigned_to === null) {
+            patch.assigned_to = actorUserId;
+        }
+        const updated = await crud.updateById(id, patch);
+        const row = Array.isArray(updated) ? updated[0] : updated;
+        if (!row)
+            throw new Error(`hazo_admin:issues — UPDATE returned no row for ${id}`);
+        return toIssueRecord(row);
+    }
+    async function setAssignee(id, userId) {
+        const ts = now();
+        const updated = await crud.updateById(id, { assigned_to: userId, updated_at: ts });
+        const row = Array.isArray(updated) ? updated[0] : updated;
+        if (!row)
+            throw new Error(`hazo_admin:issues — issue ${id} not found`);
+        return toIssueRecord(row);
+    }
+    async function resolveIssue(id, opts) {
+        const ts = now();
+        const updated = await crud.updateById(id, {
+            status: 'closed',
+            resolution: opts.resolution,
+            resolution_role_id: opts.role_id ?? null,
+            resolution_reason: opts.reason ?? null,
+            resolved_by: opts.resolved_by,
+            resolved_at: ts,
+            updated_at: ts,
+        });
+        const row = Array.isArray(updated) ? updated[0] : updated;
+        if (!row)
+            throw new Error(`hazo_admin:issues — issue ${id} not found`);
+        return toIssueRecord(row);
+    }
+    async function archiveClosedOlderThan(cutoffDate) {
+        const cutoff = cutoffDate.toISOString();
+        log.debug('createIssueStoreFromConnect:archiveClosedOlderThan', { cutoff });
+        const archived = await adapter.claimRows({
+            table: TABLE,
+            where: {
+                status: 'closed',
+                resolved_at: { lte: cutoff },
+            },
+            set: {
+                status: 'archived',
+                updated_at: { $now: true },
+            },
+            returning: ['id'],
+            limit: 1000,
+        });
+        const count = (archived ?? []).length;
+        log.debug('createIssueStoreFromConnect:archiveClosedOlderThan — archived', { count });
+        return count;
+    }
+    return {
+        createOrBumpIssue,
+        listIssues,
+        getIssue,
+        transitionStatus,
+        setAssignee,
+        resolveIssue,
+        archiveClosedOlderThan,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hazo_admin",
-  "version": "0.3.2",
+  "version": "0.6.0",
   "description": "Standard site-admin package — auth-gated admin shell + panel kit + drop-in /admin preset",
   "type": "module",
   "module": "./dist/index.js",
@@ -38,6 +38,7 @@
   },
   "files": [
     "dist",
+    "config/*.ini.sample",
     "README.md",
     "CHANGE_LOG.md",
     "SETUP_CHECKLIST.md"
@@ -51,15 +52,15 @@
   },
   "peerDependencies": {
     "hazo_core": "^1.2.0",
-    "hazo_ui": "^4.0.0",
+    "hazo_ui": "^4.4.0",
     "react": "^18.0.0 || ^19.0.0",
     "react-dom": "^18.0.0 || ^19.0.0",
     "next": "^14.0.0 || ^16.0.0",
-    "hazo_auth": "^10.2.0",
+    "hazo_auth": "^10.2.0 || ^10.3.0",
     "hazo_logs": "^2.0.2",
     "hazo_debug": "^3.1.1",
     "hazo_connect": "^3.7.0",
-    "hazo_config": "^2.1.7",
+    "hazo_config": "^2.2.0",
     "hazo_api": "^2.3.1",
     "hazo_files": "^3.0.0",
     "hazo_jobs": "^0.12.0",
@@ -69,6 +70,7 @@
     "hazo_secure": "^1.2.0",
     "hazo_blog": "^0.2.0",
     "hazo_testing": "^0.3.1",
+    "hazo_notify": "^6.1.4",
     "lucide-react": "^0.553.0"
   },
   "peerDependenciesMeta": {
@@ -113,6 +115,9 @@
     },
     "hazo_testing": {
       "optional": true
+    },
+    "hazo_notify": {
+      "optional": true
     }
   },
   "devDependencies": {
@@ -126,8 +131,8 @@
     "@types/react": "^19.0.0",
     "@types/react-dom": "^19.0.0",
     "hazo_core": "^1.2.0",
-    "hazo_ui": "^4.0.0",
-    "hazo_auth": "^10.2.0",
+    "hazo_ui": "^4.4.0",
+    "hazo_auth": "^10.3.0",
     "hazo_testing": "^0.3.1",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",