@hasna/hooks 0.4.0 → 0.4.1

package/bin/index.js

@@ -6270,7 +6270,6 @@ var init_http = () => {};
 
 // node_modules/@hasna/events/dist/commander.js
 import { chmod, mkdir, readFile, rename, writeFile } from "fs/promises";
-import { Buffer as Buffer2 } from "buffer";
 import { existsSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
@@ -6375,9 +6374,6 @@ function channelMatchesEvent(channel, event) {
 }
 var HASNA_EVENTS_DIR_ENV = "HASNA_EVENTS_DIR";
 var HASNA_EVENTS_HOME_ENV = "HASNA_EVENTS_HOME";
-var LOCAL_JSON_EVENT_CURSOR_PREFIX = "local-json-v1:";
-var DEFAULT_EVENT_PAGE_LIMIT = 100;
-var MAX_EVENT_PAGE_LIMIT = 1000;
 function getEventsDataDir(override) {
   return override || process.env[HASNA_EVENTS_DIR_ENV] || process.env[HASNA_EVENTS_HOME_ENV] || join(homedir(), ".hasna", "events");
 }
@@ -6391,13 +6387,11 @@ function getActiveEventsDirEnv() {
 
 class JsonEventsStore {
   dataDir;
-  runtime;
   channelsPath;
   eventsPath;
   deliveriesPath;
   constructor(dataDir = getEventsDataDir()) {
     this.dataDir = dataDir;
-    this.runtime = localJsonRuntime(dataDir);
     this.channelsPath = join(dataDir, "channels.json");
     this.eventsPath = join(dataDir, "events.json");
     this.deliveriesPath = join(dataDir, "deliveries.json");
@@ -6445,58 +6439,13 @@ class JsonEventsStore {
     await this.writeJson(this.eventsPath, events);
     return event;
   }
-  async appendEventOnce(event, options = {}) {
+  async listEvents() {
     await this.init();
-    const events = await this.readJson(this.eventsPath, []);
-    const dedupe = options.dedupe !== false;
-    if (dedupe) {
-      const existing = findEventByIdentity(events, { id: event.id, dedupeKey: event.dedupeKey });
-      if (existing) {
-        return {
-          event: existing,
-          stored: false,
-          deduped: true,
-          identity: { id: existing.id, dedupeKey: existing.dedupeKey }
-        };
-      }
-    }
-    events.push(event);
-    await this.writeJson(this.eventsPath, events);
-    return {
-      event,
-      stored: true,
-      deduped: false,
-      identity: { id: event.id, dedupeKey: event.dedupeKey }
-    };
-  }
-  async listEvents(options = {}) {
-    await this.init();
-    const events = await this.readJson(this.eventsPath, []);
-    return queryEvents(events, options);
-  }
-  async listEventsPage(options = {}) {
-    await this.init();
-    const events = await this.readJson(this.eventsPath, []);
-    const queried = queryEvents(events, {
-      eventId: options.eventId,
-      source: options.source,
-      type: options.type
-    });
-    const offset = decodeLocalJsonEventCursor(options.cursor, options);
-    const limit = normalizeEventPageLimit(options.limit);
-    const pageEvents = queried.slice(offset, offset + limit);
-    const nextOffset = offset + pageEvents.length;
-    const hasMore = nextOffset < queried.length;
-    return {
-      events: pageEvents,
-      cursor: options.cursor,
-      nextCursor: hasMore ? encodeLocalJsonEventCursor(nextOffset, options) : undefined,
-      hasMore
-    };
+    return this.readJson(this.eventsPath, []);
   }
   async findEventByIdentity(identity) {
     const events = await this.listEvents();
-    return findEventByIdentity(events, identity);
+    return events.find((event) => identity.id !== undefined && event.id === identity.id || identity.dedupeKey !== undefined && event.dedupeKey === identity.dedupeKey);
   }
   async appendDelivery(result) {
     await this.init();
@@ -6547,83 +6496,6 @@ class JsonEventsStore {
     });
   }
 }
-function localJsonRuntime(dataDir = getEventsDataDir()) {
-  return {
-    mode: "local-files",
-    name: "json-events-store",
-    remote: false,
-    localFiles: true,
-    localSqlite: false,
-    postgres: false,
-    s3: false,
-    aws: false,
-    durable: true,
-    idempotency: "best-effort-local",
-    replayCursors: true,
-    description: `Local JSON files in ${dataDir}; no SQLite, Postgres, S3, or AWS runtime is configured by this store.`
-  };
-}
-function encodeLocalJsonEventCursor(offset, options = {}) {
-  if (!Number.isInteger(offset) || offset < 0)
-    throw new Error(`Invalid event cursor offset: ${offset}`);
-  const payload = {
-    offset,
-    eventId: options.eventId,
-    source: options.source,
-    type: options.type
-  };
-  return `${LOCAL_JSON_EVENT_CURSOR_PREFIX}${Buffer2.from(JSON.stringify(payload), "utf-8").toString("base64url")}`;
-}
-function decodeLocalJsonEventCursor(cursor, options = {}) {
-  if (!cursor)
-    return 0;
-  if (!cursor.startsWith(LOCAL_JSON_EVENT_CURSOR_PREFIX))
-    throw new Error(`Invalid local JSON event cursor: ${cursor}`);
-  const rawPayload = cursor.slice(LOCAL_JSON_EVENT_CURSOR_PREFIX.length);
-  let payload;
-  try {
-    payload = JSON.parse(Buffer2.from(rawPayload, "base64url").toString("utf-8"));
-  } catch {
-    throw new Error(`Invalid local JSON event cursor: ${cursor}`);
-  }
-  const offset = payload.offset;
-  if (!Number.isInteger(offset) || offset < 0)
-    throw new Error(`Invalid local JSON event cursor: ${cursor}`);
-  assertCursorFilter("eventId", payload.eventId, options.eventId);
-  assertCursorFilter("source", payload.source, options.source);
-  assertCursorFilter("type", payload.type, options.type);
-  return offset;
-}
-function normalizeEventPageLimit(limit) {
-  if (limit === undefined)
-    return DEFAULT_EVENT_PAGE_LIMIT;
-  if (!Number.isInteger(limit) || limit < 1)
-    throw new Error(`Event page limit must be a positive integer, got ${limit}`);
-  return Math.min(limit, MAX_EVENT_PAGE_LIMIT);
-}
-function queryEvents(events, options) {
-  let rows = events;
-  if (options.eventId)
-    rows = rows.filter((event) => event.id === options.eventId);
-  if (options.source)
-    rows = rows.filter((event) => event.source === options.source);
-  if (options.type)
-    rows = rows.filter((event) => event.type === options.type);
-  if (options.cursor) {
-    const offset = decodeLocalJsonEventCursor(options.cursor, options);
-    rows = rows.slice(offset);
-  }
-  if (options.limit !== undefined)
-    rows = rows.slice(0, normalizeEventPageLimit(options.limit));
-  return rows;
-}
-function assertCursorFilter(name, cursorValue, optionValue) {
-  if (cursorValue !== optionValue)
-    throw new Error(`Local JSON event cursor ${name} filter mismatch`);
-}
-function findEventByIdentity(events, identity) {
-  return events.find((event) => identity.id !== undefined && event.id === identity.id || identity.dedupeKey !== undefined && event.dedupeKey === identity.dedupeKey);
-}
 async function getEventsStatus(dataDir) {
   const store = new JsonEventsStore(dataDir);
   await store.init();
@@ -6640,7 +6512,6 @@ async function getEventsStatus(dataDir) {
     service: "events",
     schemaVersion: "1.0",
     dataDir: store.dataDir,
-    storage: store.runtime,
     env: {
       primary: HASNA_EVENTS_DIR_ENV,
       fallback: HASNA_EVENTS_HOME_ENV,
@@ -6827,51 +6698,6 @@ function createDeliveryResult(event, channel, attempts) {
     completedAt: attempts.at(-1)?.completedAt ?? now()
   };
 }
-
-class EventValidationError extends Error {
-  eventType;
-  issues;
-  constructor(eventType, issues) {
-    const detail = issues.map((issue) => `${issue.path || "<root>"}: ${issue.message}`).join("; ");
-    super(`Event validation failed for type "${eventType}": ${detail}`);
-    this.name = "EventValidationError";
-    this.eventType = eventType;
-    this.issues = issues;
-  }
-}
-
-class EventTypeCatalog {
-  definitions = new Map;
-  register(definition) {
-    this.definitions.set(definition.type, definition);
-    return this;
-  }
-  unregister(type) {
-    return this.definitions.delete(type);
-  }
-  has(type) {
-    return this.definitions.has(type);
-  }
-  get(type) {
-    return this.definitions.get(type);
-  }
-  list() {
-    return [...this.definitions.values()];
-  }
-  validateEvent(event) {
-    const definition = this.definitions.get(event.type);
-    if (!definition)
-      return { ok: true };
-    return definition.validate(event.data, event);
-  }
-  assertEventValid(event) {
-    const result = this.validateEvent(event);
-    if (!result.ok) {
-      throw new EventValidationError(event.type, result.issues);
-    }
-  }
-}
-var defaultEventTypeCatalog = new EventTypeCatalog;
 function createEvent(input) {
   return {
     id: input.id ?? randomUUID2(),
@@ -6892,14 +6718,10 @@ class EventsClient {
   store;
   redactors;
   transportOptions;
-  catalog;
-  validateCatalogTypes;
   constructor(options = {}) {
     this.store = options.store ?? new JsonEventsStore(options.dataDir);
     this.redactors = options.redactors ?? [];
     this.transportOptions = { fetchImpl: options.fetchImpl };
-    this.catalog = options.catalog ?? defaultEventTypeCatalog;
-    this.validateCatalogTypes = options.validateCatalogTypes ?? false;
   }
   async addChannel(input) {
     const timestamp = new Date().toISOString();
@@ -6917,40 +6739,18 @@ class EventsClient {
   }
   async emit(input, options = {}) {
     const event = options.redactSensitiveData === false ? createEvent(input) : redactSensitiveKeys(createEvent(input));
-    if (options.validate ?? this.validateCatalogTypes) {
-      this.catalog.assertEventValid(event);
-    }
-    const append = await this.appendEvent(event, { dedupe: options.dedupe !== false });
-    if (append.deduped) {
-      return { event: append.event, deliveries: [], deduped: true };
-    }
-    const deliveries = options.deliver === false ? [] : await this.deliver(append.event);
-    return { event: append.event, deliveries, deduped: false };
-  }
-  async listEvents(options = {}) {
-    if (Object.keys(options).length === 0)
-      return this.store.listEvents();
-    return queryClientEvents(await this.store.listEvents(), options);
-  }
-  async listEventsPage(options = {}) {
-    if (this.store.listEventsPage)
-      return this.store.listEventsPage(options);
-    const events = queryClientEvents(await this.store.listEvents(), {
-      eventId: options.eventId,
-      source: options.source,
-      type: options.type
-    });
-    const offset = decodeLocalJsonEventCursor(options.cursor, options);
-    const limit = normalizeEventPageLimit(options.limit);
-    const pageEvents = events.slice(offset, offset + limit);
-    const nextOffset = offset + pageEvents.length;
-    const hasMore = nextOffset < events.length;
-    return {
-      events: pageEvents,
-      cursor: options.cursor,
-      nextCursor: hasMore ? encodeLocalJsonEventCursor(nextOffset, options) : undefined,
-      hasMore
-    };
+    if (options.dedupe !== false) {
+      const existing = await this.store.findEventByIdentity({ id: input.id, dedupeKey: event.dedupeKey });
+      if (existing) {
+        return { event: existing, deliveries: [], deduped: true };
+      }
+    }
+    await this.store.appendEvent(event);
+    const deliveries = options.deliver === false ? [] : await this.deliver(event);
+    return { event, deliveries, deduped: false };
+  }
+  async listEvents() {
+    return this.store.listEvents();
   }
   async listDeliveries() {
     return this.store.listDeliveries();
@@ -7018,37 +6818,22 @@ class EventsClient {
     return result;
   }
   async replay(options = {}) {
-    const page = options.cursor || options.limit !== undefined ? await this.listEventsPage(options) : { events: await this.listEvents(options), hasMore: false };
+    const events = (await this.store.listEvents()).filter((event) => {
+      if (options.eventId && event.id !== options.eventId)
+        return false;
+      if (options.source && event.source !== options.source)
+        return false;
+      if (options.type && event.type !== options.type)
+        return false;
+      return true;
+    });
     if (options.dryRun)
-      return { events: page.events, deliveries: [], cursor: page.cursor, nextCursor: page.nextCursor, hasMore: page.hasMore };
+      return { events, deliveries: [] };
     const deliveries = [];
-    for (const event of page.events) {
+    for (const event of events) {
       deliveries.push(...await this.deliver(event));
     }
-    return { events: page.events, deliveries, cursor: page.cursor, nextCursor: page.nextCursor, hasMore: page.hasMore };
-  }
-  async appendEvent(event, options) {
-    if (this.store.appendEventOnce) {
-      return this.store.appendEventOnce(event, { dedupe: options.dedupe });
-    }
-    if (options.dedupe) {
-      const existing = await this.store.findEventByIdentity({ id: event.id, dedupeKey: event.dedupeKey });
-      if (existing) {
-        return {
-          event: existing,
-          stored: false,
-          deduped: true,
-          identity: { id: existing.id, dedupeKey: existing.dedupeKey }
-        };
-      }
-    }
-    const stored = await this.store.appendEvent(event);
-    return {
-      event: stored,
-      stored: true,
-      deduped: false,
-      identity: { id: stored.id, dedupeKey: stored.dedupeKey }
-    };
+    return { events, deliveries };
   }
   async applyRedaction(event, channel) {
     let next = redactPaths(event, channel.redact?.paths ?? [], channel.redact?.replacement ?? "[REDACTED]");
@@ -7125,20 +6910,6 @@ function setPath(input, path, replacement) {
   if (last && last in cursor)
     cursor[last] = replacement;
 }
-function queryClientEvents(events, options) {
-  let rows = events;
-  if (options.eventId)
-    rows = rows.filter((event) => event.id === options.eventId);
-  if (options.source)
-    rows = rows.filter((event) => event.source === options.source);
-  if (options.type)
-    rows = rows.filter((event) => event.type === options.type);
-  if (options.cursor)
-    rows = rows.slice(decodeLocalJsonEventCursor(options.cursor, options));
-  if (options.limit !== undefined)
-    rows = rows.slice(0, normalizeEventPageLimit(options.limit));
-  return rows;
-}
 function normalizeTime(value) {
   if (!value)
     return new Date().toISOString();
@@ -7221,7 +6992,6 @@ function parseMatcherExpression(value, label) {
     negated: false
   };
 }
-var DEFAULT_EVENT_LIST_LIMIT = 100;
 function parseJsonObject(value, fallback) {
   if (!value)
     return fallback;
@@ -7254,14 +7024,6 @@ function print(value, json, text) {
   else
     console.log(text);
 }
-function fail(error, json) {
-  const message = error instanceof Error ? error.message : String(error);
-  if (json)
-    console.log(JSON.stringify({ error: message }, null, 2));
-  else
-    console.error(message);
-  process.exitCode = 1;
-}
 function hasJsonOption(options) {
   return Boolean(options?.json || options?.opts?.().json || options?.optsWithGlobals?.().json || options?.parent?.opts?.().json || options?.parent?.optsWithGlobals?.().json);
 }
@@ -7316,36 +7078,26 @@ function registerChannelCommands(program, options) {
     print({ removed }, wantsJson(actionOptions, command), removed ? `Removed ${id}` : `Channel not found: ${id}`);
   });
   channels.command("test").description("Send a test event to one channel").argument("<id>", "Channel identifier").option("--source <source>", "Event source override").option("--type <type>", "Event type", "events.test").option("--subject <subject>", "Event subject").option("--message <message>", "Event message", "Hasna events test delivery").option("--data <json>", "Event data JSON object").option("--metadata <json>", "Event metadata JSON object").option("--honor-filters", "Skip delivery when the sample event does not match channel filters", false).option("-j, --json", "Print JSON output", false).action(async (id, actionOptions, command) => {
-    const json = wantsJson(actionOptions, command);
-    try {
-      const result = await createClient(options).testChannel(id, {
-        source: actionOptions.source ?? options.source,
-        type: actionOptions.type,
-        subject: actionOptions.subject ?? id,
-        message: actionOptions.message,
-        data: parseJsonObject(actionOptions.data, { test: true }),
-        metadata: parseJsonObject(actionOptions.metadata, {})
-      }, { honorFilters: actionOptions.honorFilters });
-      print(result, json, `${result.status}: ${result.channelId}`);
-    } catch (error) {
-      fail(error, json);
-    }
+    const result = await createClient(options).testChannel(id, {
+      source: actionOptions.source ?? options.source,
+      type: actionOptions.type,
+      subject: actionOptions.subject ?? id,
+      message: actionOptions.message,
+      data: parseJsonObject(actionOptions.data, { test: true }),
+      metadata: parseJsonObject(actionOptions.metadata, {})
+    }, { honorFilters: actionOptions.honorFilters });
+    print(result, wantsJson(actionOptions, command), `${result.status}: ${result.channelId}`);
   });
   channels.command("match").description("Check whether a sample event matches one channel without delivering").argument("<id>", "Channel identifier").option("--source <source>", "Event source override").option("--type <type>", "Event type", "events.test").option("--subject <subject>", "Event subject").option("--message <message>", "Event message", "Hasna events match preview").option("--data <json>", "Event data JSON object").option("--metadata <json>", "Event metadata JSON object").option("-j, --json", "Print JSON output", false).action(async (id, actionOptions, command) => {
-    const json = wantsJson(actionOptions, command);
-    try {
-      const result = await createClient(options).matchChannel(id, {
-        source: actionOptions.source ?? options.source,
-        type: actionOptions.type,
-        subject: actionOptions.subject ?? id,
-        message: actionOptions.message,
-        data: parseJsonObject(actionOptions.data, { test: true }),
-        metadata: parseJsonObject(actionOptions.metadata, {})
-      });
-      print(result, json, `${result.matched ? "matched" : "skipped"}: ${result.channelId}`);
-    } catch (error) {
-      fail(error, json);
-    }
+    const result = await createClient(options).matchChannel(id, {
+      source: actionOptions.source ?? options.source,
+      type: actionOptions.type,
+      subject: actionOptions.subject ?? id,
+      message: actionOptions.message,
+      data: parseJsonObject(actionOptions.data, { test: true }),
+      metadata: parseJsonObject(actionOptions.metadata, {})
+    });
+    print(result, wantsJson(actionOptions, command), `${result.matched ? "matched" : "skipped"}: ${result.channelId}`);
   });
   return channels;
 }
@@ -7364,8 +7116,7 @@ function registerEventCommands(program, options) {
     }, { deliver: actionOptions.deliver, dedupe: actionOptions.dedupe });
     print(result, wantsJson(actionOptions, command), `${result.deduped ? "Deduped" : "Emitted"} ${result.event.id} to ${result.deliveries.length} channel(s)`);
   });
-  const defaultListLimit = options.defaultEventListLimit ?? DEFAULT_EVENT_LIST_LIMIT;
-  events.command("list").description("List recorded events").option("--source <source>", "Filter by source").option("--type <type>", "Filter by type").option("--limit <n>", `Limit to the most recent <n> events (default ${defaultListLimit}; use 0 for all)`, parseNumber, defaultListLimit).option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
+  events.command("list").description("List recorded events").option("--source <source>", "Filter by source").option("--type <type>", "Filter by type").option("--limit <n>", "Limit results", parseNumber).option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
     let rows = await createClient(options).listEvents();
     if (actionOptions.source)
       rows = rows.filter((event) => event.source === actionOptions.source);
@@ -7384,16 +7135,14 @@ function registerEventCommands(program, options) {
     for (const event of rows)
       console.log(`${event.time}	${event.id}	${event.source}	${event.type}	${event.severity}`);
   });
-  events.command("replay").description("Replay recorded events").option("--id <id>", "Replay one event id").option("--source <source>", "Filter by source").option("--type <type>", "Filter by type").option("--cursor <cursor>", "Opaque replay cursor from a previous page").option("--limit <n>", "Maximum events to replay", parseNumber).option("--dry-run", "Preview without delivery", false).option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
+  events.command("replay").description("Replay recorded events").option("--id <id>", "Replay one event id").option("--source <source>", "Filter by source").option("--type <type>", "Filter by type").option("--dry-run", "Preview without delivery", false).option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
     const result = await createClient(options).replay({
       eventId: actionOptions.id,
       source: actionOptions.source,
       type: actionOptions.type,
-      cursor: actionOptions.cursor,
-      limit: actionOptions.limit,
       dryRun: actionOptions.dryRun
     });
-    print(result, wantsJson(actionOptions, command), replaySummary(result.events.length, result.deliveries.length, result.nextCursor));
+    print(result, wantsJson(actionOptions, command), `Replayed ${result.events.length} event(s), ${result.deliveries.length} delivery result(s)`);
   });
   return events;
 }
@@ -7411,10 +7160,6 @@ function collectValues(value, previous) {
   previous.push(value);
   return previous;
 }
-function replaySummary(events, deliveries, nextCursor) {
-  const suffix = nextCursor ? `, next cursor: ${nextCursor}` : "";
-  return `Replayed ${events} event(s), ${deliveries} delivery result(s)${suffix}`;
-}
 
 // src/cli/index.tsx
 import { render } from "ink";