abxbus 2.5.4 → 2.5.9

package/dist/esm/BaseEvent.js

@@ -10,7 +10,8 @@ import {
   withResolvers
 } from "./LockManager.js";
 import { _runWithTimeout } from "./timing.js";
-import { isZodSchema, normalizeEventResultType, toJsonSchema } from "./types.js";
+import { toJsonSchema } from "./jsonschema.js";
+import { isZodSchema, normalizeEventResultType } from "./types.js";
 import { monotonicDatetime } from "./helpers.js";
 const RESERVED_USER_EVENT_FIELDS = /* @__PURE__ */ new Set([
   "bus",
@@ -83,6 +84,16 @@ const BaseEventSchema = z.object({
   event_handler_completion: z.enum(EVENT_HANDLER_COMPLETION_MODES).nullable().optional()
 }).loose();
 const KNOWN_BASE_EVENT_FIELDS = new Set(Object.keys(BaseEventSchema.shape));
+const EVENT_FACTORY_METADATA_FIELDS = /* @__PURE__ */ new Set([
+  "class",
+  "fromJSON",
+  "prototype",
+  "event_schema",
+  "model_fields",
+  "event_type",
+  "event_version",
+  "event_result_type"
+]);
 const ROOT_EVENTBUS_ID = "00000000-0000-0000-0000-000000000000";
 function baseEventDefaultShape(event_type) {
   return {
@@ -112,11 +123,67 @@ function baseEventDefaultShape(event_type) {
 function missingBaseFields(event_type, user_shape) {
   return Object.fromEntries(Object.entries(baseEventDefaultShape(event_type)).filter(([key]) => !(key in user_shape)));
 }
+function isZodLiteralValue(value) {
+  return value === null || value === void 0 || ["string", "number", "bigint", "boolean"].includes(typeof value);
+}
+function isPlainShortcutLiteralObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function alreadyComparedShortcutLiteralPair(left, right, seen) {
+  let right_values = seen.get(left);
+  if (right_values?.has(right)) {
+    return true;
+  }
+  if (!right_values) {
+    right_values = /* @__PURE__ */ new WeakSet();
+    seen.set(left, right_values);
+  }
+  right_values.add(right);
+  return false;
+}
+function shortcutLiteralValuesEqual(left, right, seen = /* @__PURE__ */ new WeakMap()) {
+  if (Object.is(left, right)) {
+    return true;
+  }
+  if (typeof left !== "object" || left === null || typeof right !== "object" || right === null) {
+    return false;
+  }
+  if (alreadyComparedShortcutLiteralPair(left, right, seen)) {
+    return true;
+  }
+  if (Array.isArray(left) || Array.isArray(right)) {
+    if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) {
+      return false;
+    }
+    return left.every((item, index) => shortcutLiteralValuesEqual(item, right[index], seen));
+  }
+  if (!isPlainShortcutLiteralObject(left) || !isPlainShortcutLiteralObject(right)) {
+    return false;
+  }
+  const left_keys = Object.keys(left);
+  const right_keys = Object.keys(right);
+  if (left_keys.length !== right_keys.length) {
+    return false;
+  }
+  return left_keys.every(
+    (key) => Object.prototype.hasOwnProperty.call(right, key) ? shortcutLiteralValuesEqual(left[key], right[key], seen) : false
+  );
+}
+function shortcutLiteralSchema(value) {
+  if (isZodLiteralValue(value)) {
+    return z.literal(value);
+  }
+  return z.custom((candidate) => shortcutLiteralValuesEqual(candidate, value), "Invalid literal value");
+}
 function shortcutDefaultSchema(base_field_schema, value) {
   if (!base_field_schema) {
-    return z.unknown().optional().default(value);
+    return shortcutLiteralSchema(value).default(value);
   }
-  return base_field_schema.prefault(base_field_schema.parse(value));
+  return base_field_schema.default(base_field_schema.parse(value));
 }
 function schemaDefaultsForShortcut(event_type, raw_shape) {
   const defaults = {};
@@ -139,10 +206,42 @@ function zodFieldsForShortcut(raw_shape) {
   }
   return fields;
 }
+function modelFieldsForShortcut(raw_shape, shortcut_shape) {
+  const event_result_type = normalizeEventResultType(raw_shape.event_result_type);
+  return event_result_type ? { ...shortcut_shape, event_result_type } : shortcut_shape;
+}
+function staticEventDefaultsFromModelFields(model_fields) {
+  const fields = {};
+  for (const [key, value] of Object.entries(model_fields)) {
+    if (EVENT_FACTORY_METADATA_FIELDS.has(key)) {
+      continue;
+    }
+    const parsed = value.safeParse(void 0);
+    if (parsed.success && parsed.data !== void 0) {
+      fields[key] = parsed.data;
+    }
+  }
+  return fields;
+}
+function defineStaticEventFields(target, fields) {
+  for (const [key, value] of Object.entries(fields)) {
+    Object.defineProperty(target, key, {
+      value,
+      writable: false,
+      enumerable: true,
+      configurable: true
+    });
+  }
+}
 function eventResultTypeFromObjectSchema(schema) {
   const raw_event_result_type = schema.shape.event_result_type;
   return raw_event_result_type === void 0 ? void 0 : normalizeEventResultType(raw_event_result_type);
 }
+function eventParseSchemaFromEventSchema(schema) {
+  return schema.safeExtend({
+    event_result_type: z.unknown().optional()
+  });
+}
 function buildFullEventSchema(event_type, spec) {
   if (isZodObjectSchema(spec)) {
     const user_shape = spec.shape;
@@ -150,11 +249,12 @@ function buildFullEventSchema(event_type, spec) {
     assertNoUnknownEventPrefixedFields(user_shape, `BaseEvent.extend(${event_type})`);
     assertNoModelPrefixedFields(user_shape, `BaseEvent.extend(${event_type})`);
     const full_schema2 = spec.safeExtend({
-      event_result_type: z.unknown().optional(),
       ...missingBaseFields(event_type, user_shape)
     });
     return {
       event_schema: full_schema2,
+      event_parse_schema: eventParseSchemaFromEventSchema(full_schema2),
+      static_field_defaults: staticEventDefaultsFromModelFields(full_schema2.shape),
       event_result_type: eventResultTypeFromObjectSchema(spec)
     };
   }
@@ -166,9 +266,12 @@ function buildFullEventSchema(event_type, spec) {
     ...schemaDefaultsForShortcut(event_type, raw_shape),
     ...zodFieldsForShortcut(raw_shape)
   };
-  const full_schema = z.object(shortcut_shape).safeExtend(missingBaseFields(event_type, shortcut_shape)).loose();
+  const model_fields = modelFieldsForShortcut(raw_shape, shortcut_shape);
+  const full_schema = z.object(model_fields).safeExtend(missingBaseFields(event_type, model_fields)).loose();
   return {
     event_schema: full_schema,
+    event_parse_schema: eventParseSchemaFromEventSchema(full_schema),
+    static_field_defaults: staticEventDefaultsFromModelFields(full_schema.shape),
     event_result_type: normalizeEventResultType(raw_shape.event_result_type),
     event_version: typeof raw_shape.event_version === "string" ? raw_shape.event_version : void 0
   };
@@ -229,12 +332,15 @@ class BaseEvent {
   event_handler_completion;
   // completion strategy: 'all' (default) waits for every handler, 'first' returns earliest non-undefined result and cancels the rest
   event_schema;
+  _event_parse_schema;
   static event_type;
   // class name of the event, e.g. BaseEvent.extend("MyEvent").event_type === "MyEvent"
   static event_version = "0.0.1";
   static event_result_type;
   static event_schema = BaseEventSchema;
   // generated Zod schema for local TS event data validation; never sent over the wire
+  static model_fields = BaseEventSchema.shape;
+  static _event_parse_schema = BaseEventSchema;
   // internal runtime state
   event_bus;
   // bus that dispatched this event, also used by event.emit(child)
@@ -257,6 +363,7 @@ class BaseEvent {
     const raw_event_result_type = merged_data.event_result_type ?? ctor.event_result_type;
     const event_result_type = normalizeEventResultType(raw_event_result_type);
     const event_schema = ctor.event_schema ?? BaseEventSchema;
+    const event_parse_schema = ctor._event_parse_schema ?? event_schema;
     const base_data = {
       ...merged_data,
       event_id: merged_data.event_id ?? uuidv7(),
@@ -265,11 +372,11 @@ class BaseEvent {
       event_version,
       event_result_type
     };
-    if (event_schema === BaseEventSchema) {
+    if (event_parse_schema === BaseEventSchema) {
       base_data.event_timeout ??= null;
       base_data.event_blocks_parent_completion ??= false;
     }
-    const parsed = decodeEventSchema(event_schema, base_data);
+    const parsed = decodeEventSchema(event_parse_schema, base_data);
     Object.assign(this, parsed);
     Object.defineProperty(this, "event_schema", {
       value: event_schema,
@@ -277,6 +384,12 @@ class BaseEvent {
       enumerable: false,
       configurable: true
     });
+    Object.defineProperty(this, "_event_parse_schema", {
+      value: event_parse_schema,
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
     Object.defineProperty(this, "_event_fields_set", {
       value: explicit_event_fields,
       writable: true,
@@ -306,34 +419,44 @@ class BaseEvent {
   static extend(event_type, shape) {
     const built = buildFullEventSchema(event_type, shape ?? {});
     const full_schema = built.event_schema;
+    const event_parse_schema = built.event_parse_schema;
+    const static_field_defaults = built.static_field_defaults;
     const event_result_type = built.event_result_type;
     const event_version = built.event_version;
-    class ExtendedEvent extends BaseEvent {
+    const EventClass = class extends BaseEvent {
       static event_schema = full_schema;
+      static model_fields = full_schema.shape;
+      static _event_parse_schema = event_parse_schema;
       static event_type = event_type;
       static event_version = event_version ?? BaseEvent.event_version;
       static event_result_type = event_result_type;
       constructor(data) {
         super(data);
       }
-    }
-    function EventFactory(data) {
-      return new ExtendedEvent(data);
-    }
-    EventFactory.event_schema = full_schema;
-    EventFactory.event_type = event_type;
-    EventFactory.event_version = event_version ?? BaseEvent.event_version;
-    EventFactory.event_result_type = event_result_type;
-    EventFactory.class = ExtendedEvent;
-    EventFactory.fromJSON = (data) => ExtendedEvent.fromJSON(data);
-    EventFactory.prototype = ExtendedEvent.prototype;
-    EVENT_TYPE_REGISTRY.set(event_type, ExtendedEvent);
-    return EventFactory;
+    };
+    Object.defineProperty(EventClass, "name", { value: event_type, configurable: true });
+    defineStaticEventFields(EventClass, static_field_defaults);
+    let CallableEventClass;
+    CallableEventClass = new Proxy(EventClass, {
+      apply(target, _this_arg, args) {
+        return Reflect.construct(target, args, target);
+      },
+      construct(target, args, new_target) {
+        return Reflect.construct(target, args, new_target === CallableEventClass ? target : new_target);
+      }
+    });
+    Object.defineProperty(EventClass.prototype, "constructor", {
+      value: CallableEventClass,
+      writable: true,
+      configurable: true
+    });
+    EVENT_TYPE_REGISTRY.set(event_type, CallableEventClass);
+    return CallableEventClass;
   }
   static fromJSON(data) {
     if (!data || typeof data !== "object") {
-      const event_schema = this.event_schema ?? BaseEventSchema;
-      const parsed = decodeEventSchema(event_schema, data);
+      const event_parse_schema = this._event_parse_schema ?? this.event_schema ?? BaseEventSchema;
+      const parsed = decodeEventSchema(event_parse_schema, data);
       return new this(parsed);
     }
     const record = { ...data };
@@ -350,9 +473,6 @@ class BaseEvent {
     if (this !== BaseEvent && ctor.event_result_type && record.event_result_type !== void 0) {
       delete record.event_result_type;
     }
-    if (record.event_result_type !== void 0 && record.event_result_type !== null) {
-      record.event_result_type = normalizeEventResultType(record.event_result_type);
-    }
     return new this(record);
   }
   static toJSONArray(events) {
@@ -377,8 +497,8 @@ class BaseEvent {
     const event_results = Object.fromEntries(
       Array.from(this.event_results.entries()).map(([handler_id, result]) => [handler_id, result.toJSON()])
     );
-    const event_schema = this.constructor.event_schema ?? this.event_schema ?? BaseEventSchema;
-    const encoded = encodeEventSchema(event_schema, {
+    const event_parse_schema = this.constructor._event_parse_schema ?? this._event_parse_schema ?? this.constructor.event_schema ?? this.event_schema ?? BaseEventSchema;
+    const encoded = encodeEventSchema(event_parse_schema, {
       ...record,
       event_id: this.event_id,
       event_type: this.event_type,