@homaiohq/napi-quickfix 0.1.0 → 0.2.0

package/dist/esm/engine.d.ts

@@ -8,6 +8,7 @@ import { EventEmitter } from 'node:events';
 import { type NativeEngineConstructor } from './native.js';
 import { Message } from './message.js';
 import { SessionID } from './session-id.js';
+import { Session } from './session.js';
 import type { ApplicationHandlers } from './application.js';
 import type { SessionSettings } from './session-settings.js';
 /** Options for constructing an {@link Initiator} or {@link Acceptor}. */
@@ -73,7 +74,11 @@ export declare abstract class Engine extends EventEmitter {
      * Stop the engine.
      *
      * Runs off the main thread and resolves once shutdown completes, keeping the
-     * event loop free for any in-flight callbacks.
+     * event loop free for any in-flight callbacks. Once it settles the engine's
+     * sessions are destroyed. A `stop()` called while another is still in flight
+     * (even from a `'logout'` listener that stop fired) returns the same Promise,
+     * so it too settles only once the sessions are gone; the first call's
+     * `force` applies to both.
      *
      * @param force When `true`, aborts immediately instead of draining gracefully.
      *
@@ -83,8 +88,42 @@ export declare abstract class Engine extends EventEmitter {
      * ```
      */
     stop(force?: boolean): Promise<void>;
-    /** Whether any session is currently logged on. */
-    isLoggedOn(): boolean;
+    /**
+     * Whether a session is logged on.
+     *
+     * With no argument: `true` if **any** of this engine's sessions is logged on.
+     * With a {@link SessionID}: `true` only if that session belongs to this engine
+     * and is logged on (`false`, not an error, for a foreign id). Always `false`
+     * before {@link Engine.start} and once {@link Engine.stop} has settled; while
+     * a graceful stop is still in progress it reports the live state.
+     *
+     * @throws {TypeError} if `sessionID` is given but is not a {@link SessionID}
+     *   (it does not fall back to the engine-wide form).
+     */
+    isLoggedOn(sessionID?: SessionID): boolean;
+    /**
+     * The ids of the sessions this engine was configured with (every `[SESSION]`
+     * in its settings). Stable for the engine's lifetime, including after
+     * {@link Engine.stop}.
+     */
+    getSessions(): SessionID[];
+    /**
+     * A handle on one of this engine's sessions.
+     *
+     * @returns The {@link Session}, or `undefined` if `sessionID` is not one of
+     *   this engine's sessions or {@link Engine.stop} has settled (that destroys
+     *   its sessions). While a stop is still in progress the sessions are alive,
+     *   so a `'logout'` listener can still read e.g. the final sequence numbers.
+     *
+     * @example
+     * ```ts
+     * initiator.on('logon', (id) => {
+     *   const session = initiator.getSession(id)!;
+     *   console.log('next seq', session.getExpectedSenderNum());
+     * });
+     * ```
+     */
+    getSession(sessionID: SessionID): Session | undefined;
     /**
      * Keep the Node.js event loop alive while the engine is running (default once
      * started). Pair with {@link Engine.unref} to let a short script exit.
@@ -111,4 +150,3 @@ export interface Engine {
     /** List the listeners registered for an event. */
     listeners<E extends keyof EngineEvents>(event: E): Array<(...args: EngineEvents[E]) => void>;
 }
-//# sourceMappingURL=engine.d.ts.map

package/dist/esm/engine.js

@@ -6,7 +6,8 @@
  */
 import { EventEmitter } from 'node:events';
 import { Message } from './message.js';
-import { SessionID } from './session-id.js';
+import { SessionID, toNativeSessionID } from './session-id.js';
+import { Session } from './session.js';
 /**
  * Base class for the FIX session engines.
  *
@@ -103,7 +104,11 @@ export class Engine extends EventEmitter {
      * Stop the engine.
      *
      * Runs off the main thread and resolves once shutdown completes, keeping the
-     * event loop free for any in-flight callbacks.
+     * event loop free for any in-flight callbacks. Once it settles the engine's
+     * sessions are destroyed. A `stop()` called while another is still in flight
+     * (even from a `'logout'` listener that stop fired) returns the same Promise,
+     * so it too settles only once the sessions are gone; the first call's
+     * `force` applies to both.
      *
      * @param force When `true`, aborts immediately instead of draining gracefully.
      *
@@ -115,9 +120,50 @@ export class Engine extends EventEmitter {
     stop(force) {
         return this.#native.stop(force);
     }
-    /** Whether any session is currently logged on. */
-    isLoggedOn() {
-        return this.#native.isLoggedOn();
+    /**
+     * Whether a session is logged on.
+     *
+     * With no argument: `true` if **any** of this engine's sessions is logged on.
+     * With a {@link SessionID}: `true` only if that session belongs to this engine
+     * and is logged on (`false`, not an error, for a foreign id). Always `false`
+     * before {@link Engine.start} and once {@link Engine.stop} has settled; while
+     * a graceful stop is still in progress it reports the live state.
+     *
+     * @throws {TypeError} if `sessionID` is given but is not a {@link SessionID}
+     *   (it does not fall back to the engine-wide form).
+     */
+    isLoggedOn(sessionID) {
+        return sessionID === undefined
+            ? this.#native.isLoggedOn()
+            : this.#native.isLoggedOn(toNativeSessionID(sessionID, 'sessionID'));
+    }
+    /**
+     * The ids of the sessions this engine was configured with (every `[SESSION]`
+     * in its settings). Stable for the engine's lifetime, including after
+     * {@link Engine.stop}.
+     */
+    getSessions() {
+        return this.#native.getSessions().map((h) => SessionID.fromNative(h));
+    }
+    /**
+     * A handle on one of this engine's sessions.
+     *
+     * @returns The {@link Session}, or `undefined` if `sessionID` is not one of
+     *   this engine's sessions or {@link Engine.stop} has settled (that destroys
+     *   its sessions). While a stop is still in progress the sessions are alive,
+     *   so a `'logout'` listener can still read e.g. the final sequence numbers.
+     *
+     * @example
+     * ```ts
+     * initiator.on('logon', (id) => {
+     *   const session = initiator.getSession(id)!;
+     *   console.log('next seq', session.getExpectedSenderNum());
+     * });
+     * ```
+     */
+    getSession(sessionID) {
+        const handle = this.#native.getSession(toNativeSessionID(sessionID, 'sessionID'));
+        return handle ? Session.fromNative(handle) : undefined;
     }
     /**
      * Keep the Node.js event loop alive while the engine is running (default once
@@ -131,4 +177,3 @@ export class Engine extends EventEmitter {
         this.#native.unref();
     }
 }
-//# sourceMappingURL=engine.js.map

package/dist/esm/enums.d.ts

@@ -1,22 +1,56 @@
+/**
+ * FIX constants.
+ *
+ * - {@link FIELD} — field-name → tag-number (e.g. `FIELD.MsgType === 35`).
+ *   Generated from QuickFIX's `FixFieldNumbers.h` (see `src/generated/fields.ts`),
+ *   so it carries every `FIX::FIELD::*` name the bundled engine knows.
+ * - value groups such as {@link MsgType} and {@link Side} (e.g.
+ *   `MsgType.Logon === 'A'`, `Side.Buy === '1'`) — one per field, generated from
+ *   QuickFIX's `FixValues.h` (see `src/generated/values.ts`), so every
+ *   `FIX::<Field>_<VALUE>` constant is here. {@link VALUES} holds all of them
+ *   keyed by field name, and each group is also importable from
+ *   `@homaiohq/napi-quickfix/values` without loading the native addon.
+ *
+ * Everything carries literal types and is frozen, so a misspelt name is a
+ * compile error and consumers cannot mutate the shared constant tables.
+ *
+ * @example
+ * ```ts
+ * import { FIELD, MsgType, enums } from '@homaiohq/napi-quickfix';
+ * msg.setField(FIELD.MsgType, MsgType.Logon);
+ * const side = enums.Side.Buy;
+ * ```
+ */
+import { FIELD } from './generated/fields.js';
+import { type ValueGroups } from './generated/values.js';
 export { FIELD, type FieldName } from './generated/fields.js';
-/** A single group of FIX constants (name → value). */
+export { VALUES, MsgType, Side, OrdType, TimeInForce, type ValueGroups, type ValueGroupName, } from './generated/values.js';
+/**
+ * A single group of FIX constants widened to a string-indexed map (name → value).
+ *
+ * Every value group and {@link FIELD} is assignable to it, so use it where a group
+ * is looked up by a `string` key the compiler cannot narrow (a name read from
+ * configuration, say) instead of the literally-typed group itself:
+ *
+ * @example
+ * ```ts
+ * const group: EnumGroup = enums[name as ValueGroupName];
+ * const code = group[valueName];
+ * ```
+ */
 export type EnumGroup = Readonly<Record<string, number | string>>;
-/** The full, frozen tree of FIX constants. */
-export type Enums = Readonly<Record<string, EnumGroup>>;
+/**
+ * The full, frozen tree of FIX constants: every value group of {@link ValueGroups}
+ * plus the {@link FIELD} tag table.
+ */
+export type Enums = ValueGroups & {
+    readonly FIELD: typeof FIELD;
+};
 /**
  * The complete tree of FIX constants (frozen), e.g. `enums.FIELD.MsgType`,
  * `enums.MsgType.Logon`, `enums.Side.Buy`.
  *
- * `enums.FIELD` is the same table as {@link FIELD}; the value groups come from
- * the native engine.
+ * `enums.FIELD` is the same table as {@link FIELD}; every other member is the
+ * same object as the corresponding {@link VALUES} group.
  */
 export declare const enums: Enums;
-/** A group of numeric FIX constants (name → number). */
-export type NumericEnumGroup = Readonly<Record<string, number>>;
-/** A group of string-valued FIX constants (name → string), e.g. {@link MsgType}. */
-export type StringEnumGroup = Readonly<Record<string, string>>;
-/** MsgType values (strings), e.g. `MsgType.Logon === 'A'`. */
-export declare const MsgType: StringEnumGroup;
-/** Side values (strings), e.g. `Side.Buy === '1'`. */
-export declare const Side: StringEnumGroup;
-//# sourceMappingURL=enums.d.ts.map

package/dist/esm/enums.js

@@ -3,13 +3,16 @@
  *
  * - {@link FIELD} — field-name → tag-number (e.g. `FIELD.MsgType === 35`).
  *   Generated from QuickFIX's `FixFieldNumbers.h` (see `src/generated/fields.ts`),
- *   so it carries every `FIX::FIELD::*` name the bundled engine knows, with
- *   literal types.
- * - value groups exported by the native engine such as {@link MsgType} and
- *   {@link Side} (e.g. `MsgType.Logon === 'A'`, `Side.Buy === '1'`).
+ *   so it carries every `FIX::FIELD::*` name the bundled engine knows.
+ * - value groups such as {@link MsgType} and {@link Side} (e.g.
+ *   `MsgType.Logon === 'A'`, `Side.Buy === '1'`) — one per field, generated from
+ *   QuickFIX's `FixValues.h` (see `src/generated/values.ts`), so every
+ *   `FIX::<Field>_<VALUE>` constant is here. {@link VALUES} holds all of them
+ *   keyed by field name, and each group is also importable from
+ *   `@homaiohq/napi-quickfix/values` without loading the native addon.
  *
- * Everything is frozen at the TS layer so consumers cannot mutate the shared
- * constant tables.
+ * Everything carries literal types and is frozen, so a misspelt name is a
+ * compile error and consumers cannot mutate the shared constant tables.
  *
  * @example
  * ```ts
@@ -19,27 +22,14 @@
  * ```
  */
 import { FIELD } from './generated/fields.js';
-import { native } from './native.js';
+import { VALUES } from './generated/values.js';
 export { FIELD } from './generated/fields.js';
-function deepFreeze(source) {
-    const out = {};
-    for (const key of Object.keys(source)) {
-        out[key] = Object.freeze({ ...source[key] });
-    }
-    // FIELD is already frozen (generated); reuse it rather than copying 6000+ keys.
-    out.FIELD = FIELD;
-    return Object.freeze(out);
-}
+export { VALUES, MsgType, Side, OrdType, TimeInForce, } from './generated/values.js';
 /**
  * The complete tree of FIX constants (frozen), e.g. `enums.FIELD.MsgType`,
  * `enums.MsgType.Logon`, `enums.Side.Buy`.
  *
- * `enums.FIELD` is the same table as {@link FIELD}; the value groups come from
- * the native engine.
+ * `enums.FIELD` is the same table as {@link FIELD}; every other member is the
+ * same object as the corresponding {@link VALUES} group.
  */
-export const enums = deepFreeze((native.enums ?? {}));
-/** MsgType values (strings), e.g. `MsgType.Logon === 'A'`. */
-export const MsgType = (enums.MsgType ?? Object.freeze({}));
-/** Side values (strings), e.g. `Side.Buy === '1'`. */
-export const Side = (enums.Side ?? Object.freeze({}));
-//# sourceMappingURL=enums.js.map
+export const enums = /* @__PURE__ */ Object.freeze({ ...VALUES, FIELD });

package/dist/esm/field-value.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Wire formatting of the `string | number` field values `Message` and `Group`
+ * accept.
+ */
+/**
+ * A field value as FIX text. Strings pass through. A number keeps its shortest
+ * round-trip digits but is written without exponent notation, which FIX numeric
+ * fields do not allow (`1e-7` → `'0.0000001'`, `1e21` →
+ * `'1000000000000000000000'`, where `String` gives `'1e-7'` and `'1e+21'`).
+ * @throws `RangeError` for `NaN` and `±Infinity`, which have no FIX form.
+ */
+export declare function formatFieldValue(value: string | number): string;

package/dist/esm/field-value.js

@@ -0,0 +1,37 @@
+/**
+ * Wire formatting of the `string | number` field values `Message` and `Group`
+ * accept.
+ */
+/**
+ * A field value as FIX text. Strings pass through. A number keeps its shortest
+ * round-trip digits but is written without exponent notation, which FIX numeric
+ * fields do not allow (`1e-7` → `'0.0000001'`, `1e21` →
+ * `'1000000000000000000000'`, where `String` gives `'1e-7'` and `'1e+21'`).
+ * @throws `RangeError` for `NaN` and `±Infinity`, which have no FIX form.
+ */
+export function formatFieldValue(value) {
+    if (typeof value !== 'number') {
+        return String(value);
+    }
+    if (!Number.isFinite(value)) {
+        throw new RangeError(`field value must be a finite number, got ${value}`);
+    }
+    const text = String(value);
+    const e = text.indexOf('e');
+    if (e === -1) {
+        return text;
+    }
+    // `[-]d[.ddd]e±n`: move the decimal point of the mantissa n places.
+    const sign = value < 0 ? '-' : '';
+    const mantissa = text.slice(sign.length, e);
+    const point = mantissa.indexOf('.');
+    const digits = mantissa.replace('.', '');
+    const at = (point === -1 ? mantissa.length : point) + Number(text.slice(e + 1));
+    if (at <= 0) {
+        return `${sign}0.${'0'.repeat(-at)}${digits}`;
+    }
+    if (at >= digits.length) {
+        return `${sign}${digits}${'0'.repeat(at - digits.length)}`;
+    }
+    return `${sign}${digits.slice(0, at)}.${digits.slice(at)}`;
+}

package/dist/esm/generated/fields.d.ts

@@ -6120,4 +6120,3 @@ export declare const FIELD: Readonly<{
 }>;
 /** Every field name known to the bundled QuickFIX, e.g. `"MsgType"`. */
 export type FieldName = keyof typeof FIELD;
-//# sourceMappingURL=fields.d.ts.map

package/dist/esm/generated/fields.js

@@ -6122,4 +6122,3 @@ export const FIELD = /* @__PURE__ */ Object.freeze({
     BatchTotalMessages: 50001,
     BatchProcessMode: 50002,
 });
-//# sourceMappingURL=fields.js.map