@hasna/events 0.1.14 → 0.1.15

package/types/durable.d.ts

@@ -0,0 +1,112 @@
+import { type TransportDispatchOptions } from "./transports.js";
+import type { ChannelConfig, DeliveryResult, EventEnvelope, EventInput } from "./types.js";
+export interface DurableEventsBrokerOptions extends TransportDispatchOptions {
+    dataDir: string;
+    databaseName?: string;
+    now?: () => Date;
+}
+export interface DurableEnqueueOptions {
+    dedupe?: boolean;
+}
+export interface DurableEnqueueResult<TData extends Record<string, unknown> = Record<string, unknown>> {
+    event: EventEnvelope<TData>;
+    deduped: boolean;
+    queued: number;
+}
+export interface DurableDrainOptions {
+    workerId?: string;
+    limit?: number;
+    leaseMs?: number;
+}
+export interface DurableDrainResult {
+    workerId: string;
+    claimed: number;
+    delivered: number;
+    retried: number;
+    dead: number;
+    lost: number;
+    deliveries: DeliveryResult[];
+}
+export interface DurableSpoolImportOptions {
+    limit?: number;
+}
+export interface DurableSpoolImportResult {
+    scanned: number;
+    imported: number;
+    deduped: number;
+    queued: number;
+}
+export interface DurableRetryDeadOptions {
+    eventId?: string;
+    channelId?: string;
+    limit?: number;
+}
+export interface DurableRetryDeadResult {
+    matched: number;
+    requeued: number;
+}
+export type DurableOutboxStatus = "pending" | "leased" | "delivered" | "dead";
+export interface DurableEventsStatus {
+    service: "events";
+    storage: "local-sqlite";
+    schemaVersion: number;
+    databasePath: string;
+    counts: {
+        channels: number;
+        enabledChannels: number;
+        events: number;
+        pending: number;
+        leased: number;
+        delivered: number;
+        dead: number;
+    };
+    safety: {
+        statusOmitsEventPayloads: true;
+        databasePersistsEventEnvelopes: true;
+        includesResolvedSecrets: false;
+        inlineWebhookSecretsAllowed: false;
+    };
+}
+export interface DurableDeliveryJob {
+    id: string;
+    event: EventEnvelope;
+    channel: ChannelConfig;
+    attempt: number;
+    workerId: string;
+}
+export interface DurableSettleResult {
+    status: "delivered" | "retry" | "dead" | "lost";
+    delivery?: DeliveryResult;
+}
+export declare function defaultWebhookSecretResolver(reference: string): string | undefined;
+export declare class DurableEventsBroker {
+    readonly dataDir: string;
+    readonly databasePath: string;
+    private readonly db;
+    private readonly now;
+    private readonly transportOptions;
+    constructor(options: DurableEventsBrokerOptions);
+    close(): void;
+    addChannel(input: Omit<ChannelConfig, "createdAt" | "updatedAt"> & Partial<Pick<ChannelConfig, "createdAt" | "updatedAt">>): ChannelConfig;
+    listChannels(): ChannelConfig[];
+    enqueue<TData extends Record<string, unknown>>(input: EventInput<TData>, options?: DurableEnqueueOptions): DurableEnqueueResult<TData>;
+    drain(options?: DurableDrainOptions): Promise<DurableDrainResult>;
+    importSpool(options?: DurableSpoolImportOptions): DurableSpoolImportResult;
+    retryDead(options?: DurableRetryDeadOptions): DurableRetryDeadResult;
+    status(): DurableEventsStatus;
+    nextWakeAt(): number | undefined;
+    private claim;
+    private settle;
+    private completeOutbox;
+    private findEvent;
+    private queueMatchingChannels;
+    private count;
+    private immediate;
+    private ensureSchema;
+    private createSchemaV1;
+    private assertSchemaV1;
+    private readSchemaVersion;
+    private applicationSchemaObjects;
+    private assertEmptyApplicationSchema;
+    private secureDatabaseFiles;
+}

package/{dist → types}/index.d.ts

@@ -8,6 +8,8 @@ export * from "./filter.js";
 export * from "./signing.js";
 export * from "./transports.js";
 export * from "./catalog.js";
+export * from "./app-event.js";
+export { redactPaths, redactSensitiveKeys } from "./redaction.js";
 export interface EventsClientOptions extends TransportDispatchOptions {
     store?: EventsStore;
     dataDir?: string;
@@ -58,7 +60,5 @@ export declare class EventsClient {
     private applyRedaction;
     private deliverWithRetry;
 }
-export declare function redactPaths<T extends EventEnvelope>(event: T, paths: string[], replacement?: string): T;
 export declare function sanitizeChannelForOutput(channel: ChannelConfig): ChannelConfig;
 export declare function sanitizeChannelsForOutput(channels: ChannelConfig[]): ChannelConfig[];
-export declare function redactSensitiveKeys<T extends EventEnvelope>(event: T, replacement?: string): T;

package/types/redaction.d.ts

@@ -0,0 +1,4 @@
+import type { EventEnvelope } from "./types.js";
+export declare function redactPaths<T extends EventEnvelope>(event: T, paths: string[], replacement?: string): T;
+export declare function redactSensitiveKeys<T extends EventEnvelope>(event: T, replacement?: string): T;
+export declare function shouldRedactKey(key: string): boolean;

package/{dist → types}/transports.d.ts

@@ -1,8 +1,15 @@
 import type { ChannelConfig, DeliveryAttempt, DeliveryResult, EventEnvelope } from "./types.js";
 export interface TransportDispatchOptions {
     fetchImpl?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+    secretResolver?: WebhookSecretResolver;
+    now?: () => Date;
 }
-export declare function buildWebhookRequest(event: EventEnvelope, channel: ChannelConfig): {
+export type WebhookSecretResolver = (reference: string) => string | undefined | Promise<string | undefined>;
+export interface BuildWebhookRequestOptions {
+    secret?: string;
+    timestamp?: string;
+}
+export declare function buildWebhookRequest(event: EventEnvelope, channel: ChannelConfig, options?: BuildWebhookRequestOptions): {
     body: string;
     headers: Record<string, string>;
 };

package/{dist → types}/types.d.ts

@@ -51,7 +51,16 @@ export interface RedactionConfig {
 }
 export interface WebhookTransportConfig {
     url: string;
+    /**
+     * Legacy inline HMAC secret. Durable stores should reject this field so
+     * credential material is never persisted with channel configuration.
+     */
     secret?: string;
+    /**
+     * Runtime-only HMAC secret reference, for example
+     * `env:HASNA_NOTES_WEBHOOK_SECRET`.
+     */
+    secretRef?: string;
     headers?: Record<string, string>;
     timeoutMs?: number;
 }