abxbus 2.5.3 → 2.5.6

package/dist/types/BaseEvent.d.ts

@@ -4,6 +4,7 @@ import { EventResult } from './EventResult.js';
 import { EventHandler } from './EventHandler.js';
 import type { EventConcurrencyMode, EventHandlerConcurrencyMode, EventHandlerCompletionMode, Deferred } from './LockManager.js';
 import { AsyncLock } from './LockManager.js';
+import { type JsonSchema } from './jsonschema.js';
 import type { EventHandlerCallable, EventResultType } from './types.js';
 export declare const BaseEventSchema: z.ZodObject<{
     event_id: z.ZodString;
@@ -42,7 +43,7 @@ export declare const BaseEventSchema: z.ZodObject<{
         first: "first";
     }>>>;
 }, z.core.$loose>;
-type AnyEventSchema = z.ZodTypeAny;
+type AnyEventSchema = z.ZodObject<z.ZodRawShape>;
 export type BaseEventData = z.infer<typeof BaseEventSchema>;
 export type BaseEventJSON = BaseEventData & Record<string, unknown>;
 type BaseEventFieldName = 'event_id' | 'event_created_at' | 'event_type' | 'event_version' | 'event_timeout' | 'event_slow_timeout' | 'event_handler_timeout' | 'event_handler_slow_timeout' | 'event_blocks_parent_completion' | 'event_parent_id' | 'event_path' | 'event_result_type' | 'event_emitted_by_handler_id' | 'event_pending_bus_count' | 'event_status' | 'event_started_at' | 'event_completed_at' | 'event_results' | 'event_concurrency' | 'event_handler_concurrency' | 'event_handler_completion';
@@ -52,20 +53,54 @@ type BaseEventFields = {
 export type BaseEventInit<TFields extends Record<string, unknown>> = TFields & Partial<BaseEventFields>;
 type BaseEventSchemaShape = typeof BaseEventSchema.shape;
 export type EventSchema<TShape extends z.ZodRawShape> = z.ZodObject<BaseEventSchemaShape & TShape>;
-type EventPayload<TShape extends z.ZodRawShape> = TShape extends Record<string, never> ? {} : z.infer<z.ZodObject<TShape>>;
+type EventPayloadShape<TShape extends z.ZodRawShape> = {
+    [K in keyof TShape as K extends BaseEventFieldName ? never : K]: TShape[K];
+};
+type EventPayload<TShape extends z.ZodRawShape> = EventPayloadShape<TShape> extends Record<string, never> ? {} : z.infer<z.ZodObject<EventPayloadShape<TShape>>>;
+type EventFactoryMetadataFieldName = 'class' | 'fromJSON' | 'prototype' | 'event_schema' | 'model_fields' | 'event_type' | 'event_version' | 'event_result_type';
+type StaticDefaultSchema = z.ZodDefault<z.ZodTypeAny> | z.ZodPrefault<z.ZodTypeAny> | z.ZodCatch<z.ZodTypeAny>;
+type EventModelFields<TShape extends z.ZodRawShape> = {
+    readonly [K in keyof TShape]: TShape[K];
+};
+type StaticEventDefaultValues<TShape extends z.ZodRawShape> = {
+    readonly [K in keyof TShape as K extends EventFactoryMetadataFieldName ? never : TShape[K] extends StaticDefaultSchema ? K : never]: z.output<TShape[K]>;
+};
+type StaticEventDefaultValuesFromSchema<TSchema extends AnyEventSchema> = TSchema extends z.ZodObject<infer TShape> ? StaticEventDefaultValues<TShape> : {};
+type EventModelFieldsFromSchema<TSchema extends AnyEventSchema> = TSchema extends z.ZodObject<infer TShape> ? TSchema['shape'] & EventModelFields<TShape> : {};
+type OptionalFactoryArgs<TData> = {} extends TData ? [data?: TData] : [data: TData];
 type EventInput<TShape extends z.ZodRawShape> = z.input<EventSchema<TShape>>;
 export type EventInit<TShape extends z.ZodRawShape> = Omit<EventInput<TShape>, keyof BaseEventFields> & Partial<BaseEventFields>;
-type EventPayloadFromSchema<TSchema extends AnyEventSchema> = z.output<TSchema> extends Record<string, unknown> ? z.output<TSchema> : {};
+type EventPayloadFromSchema<TSchema extends AnyEventSchema> = z.output<TSchema> extends Record<string, unknown> ? Omit<z.output<TSchema>, keyof BaseEventFields> : {};
 type EventInputFromSchema<TSchema extends AnyEventSchema> = z.input<TSchema> extends Record<string, unknown> ? z.input<TSchema> : never;
 export type EventInitFromSchema<TSchema extends AnyEventSchema> = Omit<EventInputFromSchema<TSchema>, keyof BaseEventFields> & Partial<BaseEventFields>;
 type EventWithResultSchema<TResult> = BaseEvent & {
     __event_result_type__?: TResult;
 };
-type ResultTypeFromEventResultTypeInput<TInput> = TInput extends z.ZodTypeAny ? z.infer<TInput> : TInput extends StringConstructor ? string : TInput extends NumberConstructor ? number : TInput extends BooleanConstructor ? boolean : TInput extends ArrayConstructor ? unknown[] : TInput extends ObjectConstructor ? Record<string, unknown> : unknown;
+type NormalizedEventResultSchema<TInput> = TInput extends z.ZodTypeAny ? TInput : TInput extends z.core.$ZodType ? z.ZodType<z.output<TInput>> : TInput extends StringConstructor ? z.ZodString : TInput extends NumberConstructor ? z.ZodNumber : TInput extends BooleanConstructor ? z.ZodBoolean : TInput extends ArrayConstructor ? z.ZodArray<z.ZodUnknown> : TInput extends ObjectConstructor ? z.ZodRecord<z.ZodString, z.ZodUnknown> : TInput extends JsonSchema ? z.ZodTypeAny : z.ZodTypeAny;
+type ResultTypeSchemaFromShape<TShape> = TShape extends {
+    event_result_type: infer S;
+} ? NormalizedEventResultSchema<S> : z.ZodTypeAny | undefined;
+type ResultTypeSchemaFromEventSchema<TSchema> = TSchema extends z.ZodObject<infer TShape> ? ResultTypeSchemaFromShape<TShape> : z.ZodTypeAny | undefined;
+type ResultTypeFromEventResultTypeInput<TInput> = TInput extends z.ZodTypeAny ? z.infer<TInput> : TInput extends z.core.$ZodType ? z.output<TInput> : TInput extends StringConstructor ? string : TInput extends NumberConstructor ? number : TInput extends BooleanConstructor ? boolean : TInput extends ArrayConstructor ? unknown[] : TInput extends ObjectConstructor ? Record<string, unknown> : TInput extends JsonSchema ? unknown : unknown;
 type ResultSchemaFromShape<TShape> = TShape extends {
     event_result_type: infer S;
 } ? ResultTypeFromEventResultTypeInput<S> : unknown;
 type ResultSchemaFromEventSchema<TSchema> = TSchema extends z.ZodObject<infer TShape> ? ResultSchemaFromShape<TShape> : unknown;
+type ZodLiteralValue = string | number | bigint | boolean | null | undefined;
+type ShortcutDefaultModelField<K, TValue> = K extends keyof BaseEventSchemaShape ? z.ZodDefault<BaseEventSchemaShape[K]> : z.ZodDefault<TValue extends ZodLiteralValue ? z.ZodLiteral<TValue> : z.ZodType<TValue>>;
+type ShortcutModelFields<TShape> = {
+    [K in keyof TShape as K extends 'event_result_type' ? never : K]: TShape[K] extends z.ZodTypeAny ? TShape[K] : ShortcutDefaultModelField<K, TShape[K]>;
+} & (TShape extends {
+    event_result_type: infer TResultType;
+} ? {
+    event_result_type: NormalizedEventResultSchema<TResultType>;
+} : {});
+type ShortcutZodModelFields<TShape> = {
+    [K in keyof ShortcutModelFields<TShape>]: ShortcutModelFields<TShape>[K] extends z.ZodTypeAny ? ShortcutModelFields<TShape>[K] : never;
+};
+type ShortcutStaticDefaultValues<TShape, TModelFields extends z.ZodRawShape> = StaticEventDefaultValues<TModelFields> & {
+    readonly [K in keyof TShape as K extends EventFactoryMetadataFieldName ? never : TShape[K] extends z.ZodTypeAny ? never : K]: TShape[K];
+};
 export type EventResultInclude<TEvent extends BaseEvent> = (result: EventResult<TEvent>['result'], event_result: EventResult<TEvent>) => boolean;
 export type EventResultOptions<TEvent extends BaseEvent> = {
     include?: EventResultInclude<TEvent>;
@@ -86,28 +121,35 @@ type EventResultUpdateOptions<TEvent extends BaseEvent> = {
     result?: EventResultType<TEvent> | BaseEvent | undefined;
     error?: unknown;
 };
-export type EventFactory<TShape extends z.ZodRawShape, TResult = unknown> = {
-    (data: EventInit<TShape>): EventWithResultSchema<TResult> & EventPayload<TShape>;
-    new (data: EventInit<TShape>): EventWithResultSchema<TResult> & EventPayload<TShape>;
+export type EventFactoryClass<TShape extends z.ZodRawShape, TResult = unknown> = (new (...args: OptionalFactoryArgs<EventInit<TShape>>) => EventWithResultSchema<TResult> & EventPayload<TShape>) & StaticEventDefaultValues<TShape> & {
     event_schema: EventSchema<TShape>;
-    class?: new (data: EventInit<TShape>) => EventWithResultSchema<TResult> & EventPayload<TShape>;
-    event_type?: string;
-    event_version?: string;
-    event_result_type?: z.ZodTypeAny;
-    fromJSON?: (data: unknown) => EventWithResultSchema<TResult> & EventPayload<TShape>;
+    model_fields: EventModelFields<TShape>;
 };
-export type SchemaEventFactory<TSchema extends AnyEventSchema, TResult = unknown> = {
-    (data: EventInitFromSchema<TSchema>): EventWithResultSchema<TResult> & EventPayloadFromSchema<TSchema>;
-    new (data: EventInitFromSchema<TSchema>): EventWithResultSchema<TResult> & EventPayloadFromSchema<TSchema>;
+export type EventFactory<TShape extends z.ZodRawShape, TResult = unknown, TStaticFields = StaticEventDefaultValues<TShape>> = TStaticFields & {
+    (...args: OptionalFactoryArgs<EventInit<TShape>>): EventWithResultSchema<TResult> & EventPayload<TShape>;
+    new (...args: OptionalFactoryArgs<EventInit<TShape>>): EventWithResultSchema<TResult> & EventPayload<TShape>;
+    event_schema: EventSchema<TShape>;
+    model_fields: EventModelFields<TShape>;
+    class: EventFactoryClass<TShape, TResult>;
+    event_type: string;
+    event_version: string;
+    event_result_type: ResultTypeSchemaFromShape<TShape>;
+    fromJSON: (data: unknown) => EventWithResultSchema<TResult> & EventPayload<TShape>;
+};
+export type SchemaEventFactoryClass<TSchema extends AnyEventSchema, TResult = unknown> = (new (...args: OptionalFactoryArgs<EventInitFromSchema<TSchema>>) => EventWithResultSchema<TResult> & EventPayloadFromSchema<TSchema>) & StaticEventDefaultValuesFromSchema<TSchema> & {
     event_schema: TSchema;
-    class?: new (data: EventInitFromSchema<TSchema>) => EventWithResultSchema<TResult> & EventPayloadFromSchema<TSchema>;
-    event_type?: string;
-    event_version?: string;
-    event_result_type?: z.ZodTypeAny;
-    fromJSON?: (data: unknown) => EventWithResultSchema<TResult> & EventPayloadFromSchema<TSchema>;
+    model_fields: EventModelFieldsFromSchema<TSchema>;
 };
-type ZodShapeFrom<TShape extends Record<string, unknown>> = {
-    [K in keyof TShape as K extends 'event_result_type' ? never : TShape[K] extends z.ZodTypeAny ? K : never]: Extract<TShape[K], z.ZodTypeAny>;
+export type SchemaEventFactory<TSchema extends AnyEventSchema, TResult = unknown> = StaticEventDefaultValuesFromSchema<TSchema> & {
+    (...args: OptionalFactoryArgs<EventInitFromSchema<TSchema>>): EventWithResultSchema<TResult> & EventPayloadFromSchema<TSchema>;
+    new (...args: OptionalFactoryArgs<EventInitFromSchema<TSchema>>): EventWithResultSchema<TResult> & EventPayloadFromSchema<TSchema>;
+    event_schema: TSchema;
+    model_fields: EventModelFieldsFromSchema<TSchema>;
+    class: SchemaEventFactoryClass<TSchema, TResult>;
+    event_type: string;
+    event_version: string;
+    event_result_type: ResultTypeSchemaFromEventSchema<TSchema>;
+    fromJSON: (data: unknown) => EventWithResultSchema<TResult> & EventPayloadFromSchema<TSchema>;
 };
 export declare class BaseEvent {
     event_id: string;
@@ -132,10 +174,13 @@ export declare class BaseEvent {
     event_handler_concurrency?: EventHandlerConcurrencyMode | null;
     event_handler_completion?: EventHandlerCompletionMode | null;
     event_schema?: z.ZodTypeAny;
+    _event_parse_schema?: z.ZodTypeAny;
     static event_type?: string;
     static event_version: string;
     static event_result_type?: z.ZodTypeAny;
     static event_schema: AnyEventSchema;
+    static model_fields: z.ZodRawShape;
+    static _event_parse_schema: AnyEventSchema;
     event_bus?: EventBus;
     _event_original?: BaseEvent;
     _event_dispatch_context?: unknown | null;
@@ -145,8 +190,8 @@ export declare class BaseEvent {
     constructor(data?: BaseEventInit<Record<string, unknown>>);
     toString(): string;
     static extend<TSchema extends z.ZodObject<z.ZodRawShape>>(event_type: string, event_schema: TSchema): SchemaEventFactory<TSchema, ResultSchemaFromEventSchema<TSchema>>;
+    static extend<const TShape extends Record<string, unknown>>(event_type: string, shape?: TShape): EventFactory<ShortcutZodModelFields<TShape>, ResultSchemaFromShape<ShortcutZodModelFields<TShape>>, ShortcutStaticDefaultValues<TShape, ShortcutZodModelFields<TShape>>>;
     static extend<TShape extends z.ZodRawShape>(event_type: string, shape?: TShape): EventFactory<TShape, ResultSchemaFromShape<TShape>>;
-    static extend<TShape extends Record<string, unknown>>(event_type: string, shape?: TShape): EventFactory<ZodShapeFrom<TShape>, ResultSchemaFromShape<TShape>>;
     static fromJSON<T extends typeof BaseEvent>(this: T, data: unknown): InstanceType<T>;
     static toJSONArray(events: Iterable<BaseEvent>): BaseEventJSON[];
     static fromJSONArray(data: unknown): BaseEvent[];

package/dist/types/base_event.d.ts

@@ -27,7 +27,7 @@ export declare const BaseEventSchema: z.ZodObject<{
     }>>;
     event_started_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     event_completed_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    event_results: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    event_results: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
     event_concurrency: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
         "global-serial": "global-serial";
         "bus-serial": "bus-serial";
@@ -133,7 +133,7 @@ export declare class BaseEvent {
         }>>;
         event_started_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         event_completed_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        event_results: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        event_results: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
         event_concurrency: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
             "global-serial": "global-serial";
             "bus-serial": "bus-serial";

package/dist/types/bridge_ipc.d.ts

@@ -0,0 +1,45 @@
+import { BaseEvent } from './base_event.js';
+import { EventBus } from './event_bus.js';
+import type { EventClass, EventHandlerCallable, UntypedEventHandlerFunction } from './types.js';
+type EndpointScheme = 'unix' | 'http' | 'https';
+type ParsedEndpoint = {
+    raw: string;
+    scheme: EndpointScheme;
+    host?: string;
+    port?: number;
+    path?: string;
+};
+export type HTTPEventBridgeOptions = {
+    send_to?: string | null;
+    listen_on?: string | null;
+    name?: string;
+};
+export declare class EventBridge {
+    readonly send_to: ParsedEndpoint | null;
+    readonly listen_on: ParsedEndpoint | null;
+    readonly name: string;
+    protected readonly inbound_bus: EventBus;
+    private start_promise;
+    private node_server;
+    constructor(send_to?: string | null, listen_on?: string | null, name?: string);
+    on<T extends BaseEvent>(event_pattern: EventClass<T>, handler: EventHandlerCallable<T>): void;
+    on<T extends BaseEvent>(event_pattern: string | '*', handler: UntypedEventHandlerFunction<T>): void;
+    emit<T extends BaseEvent>(event: T): Promise<void>;
+    dispatch<T extends BaseEvent>(event: T): Promise<void>;
+    start(): Promise<void>;
+    close(): Promise<void>;
+    private ensureListenerStarted;
+    private handleIncomingPayload;
+    private sendHttp;
+    private sendUnix;
+    private startHttpListener;
+    private startUnixListener;
+}
+export declare class HTTPEventBridge extends EventBridge {
+    constructor(send_to?: string | null, listen_on?: string | null, name?: string);
+    constructor(options?: HTTPEventBridgeOptions);
+}
+export declare class SocketEventBridge extends EventBridge {
+    constructor(path?: string | null, name?: string);
+}
+export {};

package/dist/types/event_handler.d.ts

@@ -61,6 +61,7 @@ export declare class EventHandler {
         eventbus_id: string;
     });
     get _handler_async(): EventHandlerCallable;
+    static handlerNameFromCallable(handler: EventHandlerCallable): string;
     static computeHandlerId(params: {
         eventbus_id: string;
         handler_name: string;

package/dist/types/events_suck.d.ts

@@ -22,7 +22,7 @@ export type GeneratedEvents<TEvents extends FunctionMap> = {
 } & {
     [K in keyof TEvents]: GeneratedEvent<TEvents[K]>;
 };
-type EventInit<TEventClass extends EventClass<BaseEvent>> = ConstructorParameters<TEventClass> extends [infer TInit, ...unknown[]] ? TInit : never;
+type EventInit<TEventClass extends EventClass<BaseEvent>> = [ConstructorParameters<TEventClass>[0]] extends [undefined] ? {} : NonNullable<ConstructorParameters<TEventClass>[0]>;
 type EventMethodArgs<TEventClass extends EventClass<BaseEvent>> = {} extends EventInit<TEventClass> ? [init?: EventInit<TEventClass>, extra?: Record<string, unknown>] : [init: EventInit<TEventClass>, extra?: Record<string, unknown>];
 type EventMethodResult<TEventClass extends EventClass<BaseEvent>> = EventResultType<InstanceType<TEventClass>> | undefined;
 export type EventsSuckClient<TEvents extends EventMap> = {

package/dist/types/jsonschema.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export type JsonSchema = boolean | z.core.JSONSchema.JSONSchema;
+export declare const isJsonSchema: (value: unknown) => value is JsonSchema;
+export declare const normalizeJsonSchema: (schema: JsonSchema) => JsonSchema;
+export declare const toJsonSchema: (schema: z.core.$ZodType) => JsonSchema;
+export declare const fromJsonSchema: (schema: JsonSchema) => z.ZodTypeAny;

package/dist/types/middleware_otel_tracing.d.ts

@@ -0,0 +1,49 @@
+import { trace, type Span, type SpanAttributes, type SpanContext, type TimeInput, type Tracer } from '@opentelemetry/api';
+import type { BaseEvent } from './base_event.js';
+import type { EventBus } from './event_bus.js';
+import type { EventResult } from './event_result.js';
+import type { EventBusMiddleware } from './middlewares.js';
+import type { EventStatus } from './types.js';
+type OpenTelemetryTraceApi = Pick<typeof trace, 'getTracer' | 'setSpan'> & Partial<Pick<typeof trace, 'setSpanContext'>>;
+export type OtelTracingSpanFactoryInput = {
+    name: string;
+    span_context: SpanContext;
+    parent_span_context?: SpanContext;
+    attributes: SpanAttributes;
+    start_time?: TimeInput;
+};
+export type OtelTracingSpanFactory = (input: OtelTracingSpanFactoryInput) => Span;
+export type OtelTracingSpanProvider = object;
+export type OtelTracingMiddlewareOptions = {
+    tracer?: Tracer;
+    trace_api?: OpenTelemetryTraceApi;
+    span_provider?: OtelTracingSpanProvider;
+    span_factory?: OtelTracingSpanFactory;
+    otlp_endpoint?: string;
+    service_name?: string;
+    instrumentation_name?: string;
+    root_span_attributes?: SpanAttributes | ((eventbus: EventBus, event: BaseEvent) => SpanAttributes);
+};
+export declare class OtelTracingMiddleware implements EventBusMiddleware {
+    private readonly tracer;
+    private readonly trace_api;
+    private readonly span_factory?;
+    private readonly span_provider?;
+    private readonly root_span_attributes;
+    private readonly event_spans;
+    private readonly event_contexts;
+    private readonly handler_spans;
+    private readonly handler_contexts;
+    constructor(options?: OtelTracingMiddlewareOptions);
+    onEventChange(eventbus: EventBus, event: BaseEvent, status: EventStatus): void;
+    onEventResultChange(eventbus: EventBus, event: BaseEvent, event_result: EventResult, status: EventStatus): void;
+    private startEventSpan;
+    private completeEventSpan;
+    private startHandlerSpan;
+    private completeHandlerSpan;
+    private parentContextForEvent;
+    private completeEventSpanWithFactory;
+    private exportEventTreeWithFactory;
+    private exportHandlerSpanWithFactory;
+}
+export {};

package/dist/types/types.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import type { BaseEvent } from './BaseEvent.js';
+import { type JsonSchema } from './jsonschema.js';
 export type EventStatus = 'pending' | 'started' | 'completed';
 export type EventClass<T extends BaseEvent = BaseEvent> = {
     event_type?: string;
@@ -12,7 +13,7 @@ export type EventResultType<TEvent extends BaseEvent> = TEvent extends {
     __event_result_type__?: infer TResult;
 } ? TResult : unknown;
 export type EventResultTypeConstructor = StringConstructor | NumberConstructor | BooleanConstructor | ArrayConstructor | ObjectConstructor;
-export type EventResultTypeInput = z.ZodTypeAny | EventResultTypeConstructor | unknown;
+export type EventResultTypeInput = z.ZodTypeAny | EventResultTypeConstructor | JsonSchema;
 export type EventHandlerReturn<T extends BaseEvent = BaseEvent> = EventResultType<T> | BaseEvent | null | void;
 export type EventHandlerCallable<T extends BaseEvent = BaseEvent> = (event: T) => EventHandlerReturn<T> | Promise<EventHandlerReturn<T>>;
 export type UntypedEventHandlerFunction<T extends BaseEvent = BaseEvent> = (event: T) => EventHandlerReturn<T> | unknown | Promise<EventHandlerReturn<T> | unknown>;
@@ -33,7 +34,5 @@ export declare const normalizeEventPattern: (event_pattern: EventPattern | "*")
 export declare const isZodSchema: (value: unknown) => value is z.ZodTypeAny;
 export declare const eventResultTypeFromConstructor: (value: unknown) => z.ZodTypeAny | undefined;
 export declare const extractZodShape: (raw: Record<string, unknown>) => z.ZodRawShape;
-export declare const toJsonSchema: (schema: unknown) => unknown;
-export declare const fromJsonSchema: (schema: unknown) => z.ZodTypeAny;
-export declare const normalizeEventResultType: (value: EventResultTypeInput) => z.ZodTypeAny | undefined;
+export declare function normalizeEventResultType(value: unknown): z.ZodTypeAny | undefined;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abxbus",
-  "version": "2.5.3",
+  "version": "2.5.6",
   "description": "Event bus library for browsers and ESM Node.js",
   "type": "module",
   "sideEffects": false,