@imqueue/async-logger 3.0.1 → 3.2.0

package/src/Logger.js

@@ -1,16 +1,66 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Logger = void 0;
-const winston_1 = require("winston");
-const helpers_1 = require("./helpers");
+/*!
+ * I'm Queue Software Project
+ * Copyright (C) 2025  imqueue.com <support@imqueue.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * If you want to use this code in a closed source (commercial) project, you can
+ * purchase a proprietary commercial license. Please contact us at
+ * <support@imqueue.com> to get commercial licensing options.
+ */
+import {} from './types.js';
+import { createLogger, format, Logger as WinstonLogger, } from 'winston';
+import { buildMessage, defaultMetadata, getTransport, transportsConfig, } from './helpers/index.js';
+import {} from './TransportOptions.js';
 /**
- * Class Logger
+ * Logger that writes to the console without blocking the caller and forwards the
+ * same records to any configured winston transports.
+ *
+ * @remarks
+ * Implements {@link ILogger}, so it drops into anything in `@imqueue` that accepts
+ * a logger — `IMQClient`, `IMQService`, `RedisCache` — replacing the default
+ * synchronous console.
+ *
+ * Console output is scheduled with `setTimeout` rather than written inline. That
+ * is the point of the package: a service logging heavily does not pay for it on
+ * the request path. It also means ordering against synchronous code is not
+ * guaranteed, and output queued at the moment of `process.exit()` is lost.
+ *
+ * Transports are optional. Constructed with none — the default when
+ * `LOGGER_TRANSPORTS` is unset — this behaves as an async console logger and
+ * never touches winston.
+ *
+ * @example
+ * ```typescript
+ * import { Logger } from '@imqueue/async-logger';
+ *
+ * // configured from LOGGER_TRANSPORTS / LOGGER_METADATA
+ * const logger = new Logger();
+ *
+ * // or explicitly, e.g. to tag one subsystem differently
+ * const audit = new Logger({
+ *     transports: [{ type: 'file', options: { filename: 'audit.log' }, enabled: true }],
+ *     metadata: { subsystem: 'audit' },
+ * });
+ *
+ * audit.info('user %s signed in', userId);
+ * ```
  */
-class Logger {
+export class Logger {
     /**
-     * Asynchronous console async-logger
-     *
-     * @type {ILogger}
+     * Console bound through `setTimeout`, so every write is deferred to a later
+     * tick instead of blocking the caller.
      */
     static console = {
         // oxlint-disable-next-line no-console -- forwarding is the API here
@@ -20,91 +70,108 @@ class Logger {
         error: (...args) => setTimeout(() => console.error(...args)),
     };
     /**
-     * @description
-     * Configuring options of async-logger
+     * Builds the winston options every transport shares: JSON formatting, the
+     * given (or environment-derived) default metadata, and `exitOnError: false`
+     * so a transport failure never takes the process down.
      *
-     * @returns {LoggerOptions}
+     * @param metadata - fields to attach to every record; falls back to
+     *                   `LOGGER_METADATA` when omitted
+     * @returns winston logger options
      */
     static getLoggerOptions(metadata) {
         return {
             exitOnError: false,
-            format: winston_1.format.json(),
-            defaultMeta: metadata || (0, helpers_1.defaultMetadata)(),
+            format: format.json(),
+            defaultMeta: metadata || defaultMetadata(),
         };
     }
     /**
-     * Winston based async-logger having different logging transports
-     *
-     * @type {WinstonLogger}
+     * The winston logger the transports are attached to. Left undefined when no
+     * enabled transport was configured, which is how console-only mode is
+     * represented — every method checks it before forwarding.
      */
     logger;
     /**
-     * Logger Ctor
-     *
-     * @constructor
-     * @param {AsyncLoggerOptions} options
+     * @param options - explicit transports and metadata. Omit either half and it
+     *                  is read from `LOGGER_TRANSPORTS` / `LOGGER_METADATA`; omit
+     *                  the argument entirely and both are.
+     * @throws TypeError if the environment config is not valid JSON, or names a
+     *         transport type other than `file` or `http`
      */
     constructor(options) {
         const opts = Logger.getLoggerOptions((options || {}).metadata);
-        const config = (options || {}).transports || (0, helpers_1.transportsConfig)();
+        const config = (options || {}).transports || transportsConfig();
         if (config && config.length) {
-            this.logger = (0, winston_1.createLogger)(opts);
+            this.logger = createLogger(opts);
             this.setupLogger(config);
         }
     }
     /**
-     * Logs given arguments to configured async-logger destinations and to stdout
-     * with log level = LOG
+     * Logs to the console and to every configured transport.
      *
-     * @param {...*[]} args
+     * @remarks
+     * Reaches transports at winston's `info` level — there is no distinct `log`
+     * level — so records from here and from {@link Logger.info} are
+     * indistinguishable once shipped. They differ only in the console method
+     * used. Pick by the destination you care about.
+     *
+     * @param args - `console.log`-style arguments; the first may be a format
+     *               string with `%s`/`%d`/`%j` placeholders for the rest
      */
     log(...args) {
         Logger.console.log(...args);
         if (this.logger) {
-            this.logger.info((0, helpers_1.buildMessage)(args));
+            this.logger.info(buildMessage(args));
         }
     }
     /**
-     * Logs given arguments to configured async-logger destinations and to stdout
-     * with log level = INFO
+     * Logs at INFO level — routine progress worth keeping.
      *
-     * @param {...*[]} args
+     * @param args - `console.info`-style arguments; the first may be a format
+     *               string with `%s`/`%d`/`%j` placeholders for the rest
      */
     info(...args) {
         Logger.console.info(...args);
         if (this.logger) {
-            this.logger.info((0, helpers_1.buildMessage)(args));
+            this.logger.info(buildMessage(args));
         }
     }
     /**
-     * Logs given arguments to configured async-logger destinations and to stderr
-     * with log level = WARN
+     * Logs at WARN level — something recovered from, but worth seeing.
      *
-     * @param {...*[]} args
+     * @param args - `console.warn`-style arguments; the first may be a format
+     *               string with `%s`/`%d`/`%j` placeholders for the rest
      */
     warn(...args) {
         Logger.console.warn(...args);
         if (this.logger) {
-            this.logger.warn((0, helpers_1.buildMessage)(args));
+            this.logger.warn(buildMessage(args));
         }
     }
     /**
-     * Logs given arguments to configured async-logger destinations and to stderr
-     * with log level = ERROR
+     * Logs at ERROR level.
+     *
+     * @remarks
+     * Pass an `Error` and it is formatted like the console would — including the
+     * stack. Passing `error.stack` explicitly is the usual choice when the record
+     * has to stay one line for a log shipper.
      *
-     * @param {...*[]} args
+     * @param args - `console.error`-style arguments; the first may be a format
+     *               string with `%s`/`%d`/`%j` placeholders for the rest
      */
     error(...args) {
         Logger.console.error(...args);
         if (this.logger) {
-            this.logger.error((0, helpers_1.buildMessage)(args));
+            this.logger.error(buildMessage(args));
         }
     }
     /**
-     * Configuring transports of async-logger
+     * Creates and attaches each enabled transport from the given config.
      *
-     * @param {TransportOptions[]} config - configuration for transports from
-     *                             environment variables
+     * @param config - transport definitions, from {@link AsyncLoggerOptions} or
+     *                 parsed out of `LOGGER_TRANSPORTS`
+     * @throws TypeError if `config` is not an array, or an enabled entry names a
+     *         transport type other than `file` or `http`
      */
     setupLogger(config) {
         if (!config || !Array.isArray(config)) {
@@ -114,7 +181,14 @@ class Logger {
             if (!options.enabled) {
                 continue;
             }
-            const transport = (0, helpers_1.getTransport)(options.type, options.options);
+            const transport = getTransport(options.type, options.options);
+            // getTransport() yields nothing for a type it does not know. Report
+            // the offending type here: winston would otherwise reject the null
+            // with "Invalid transport, must be an object with a log method",
+            // which names neither the type nor the config it came from.
+            if (!transport) {
+                throw new TypeError(`Logger: unknown transport type "${options.type}", expected "file" or "http"!`);
+            }
             // the constructor always creates the winston logger before
             // calling setupLogger(), the optional chaining only satisfies
             // strict property-initialization analysis
@@ -122,5 +196,4 @@ class Logger {
         }
     }
 }
-exports.Logger = Logger;
 //# sourceMappingURL=Logger.js.map

package/src/TransportOptions.d.ts

@@ -19,12 +19,46 @@
  * purchase a proprietary commercial license. Please contact us at
  * <support@imqueue.com> to get commercial licensing options.
  */
-import { LoggerOptions } from 'winston';
+import { type LoggerOptions } from 'winston';
 /**
- * Interface IConfig
+ * One transport declaration — the shape of each element in the
+ * `LOGGER_TRANSPORTS` JSON array.
+ *
+ * @example
+ * ```json
+ * {
+ *     "type": "http",
+ *     "options": {
+ *         "ssl": true,
+ *         "port": 443,
+ *         "host": "http-intake.logs.datadoghq.com",
+ *         "path": "/v1/input/<API_KEY>"
+ *     },
+ *     "enabled": true
+ * }
+ * ```
  */
 export interface TransportOptions {
+    /**
+     * Which transport to create: `'file'` or `'http'`. Any other value is
+     * rejected at construction time.
+     */
     type: string;
+    /**
+     * Options handed to the winston transport constructor — `filename` for
+     * `file`, `host`/`port`/`path`/`ssl` for `http`.
+     *
+     * @remarks
+     * Typed as winston's `LoggerOptions` for historical reasons, which is wider
+     * than what is actually accepted here. Treat it as `FileTransportOptions` or
+     * `HttpTransportOptions` according to `type`; the declared type will not
+     * catch a mismatch for you.
+     */
     options: LoggerOptions;
+    /**
+     * Whether to attach this transport. A `false` entry is skipped entirely, so
+     * a transport can be left in the config and switched off per environment
+     * rather than deleted.
+     */
     enabled: boolean;
 }

package/src/TransportOptions.js

@@ -1,3 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+/*!
+ * I'm Queue Software Project
+ * Copyright (C) 2025  imqueue.com <support@imqueue.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * If you want to use this code in a closed source (commercial) project, you can
+ * purchase a proprietary commercial license. Please contact us at
+ * <support@imqueue.com> to get commercial licensing options.
+ */
+import {} from 'winston';
 //# sourceMappingURL=TransportOptions.js.map

package/src/helpers/env.d.ts

@@ -19,26 +19,49 @@
  * purchase a proprietary commercial license. Please contact us at
  * <support@imqueue.com> to get commercial licensing options.
  */
-import { JsonObject } from '@imqueue/core';
-import { TransportOptions } from '../TransportOptions';
+import { type JsonObject } from '../types.js';
+import { type TransportOptions } from '../TransportOptions.js';
 /**
- * Retrieve package name and version from package.json of running service
+ * Reads the running service's own name and version, used to expand the `%name`
+ * and `%version` placeholders in the logger environment variables.
  *
- * @returns {name: string, value: string} - return package name and version
+ * @remarks
+ * Resolved from `package.json` in the process's CURRENT WORKING DIRECTORY, not
+ * from this package's location. A service started from a different directory
+ * therefore reports whatever it finds there, and one started somewhere with no
+ * `package.json` falls back to `{ name: 'logger', version: '' }` rather than
+ * failing.
+ *
+ * @returns the service name and version, or the fallback pair
  */
 export declare function pkg(): {
     name: string;
     version: string;
 };
 /**
- * Used for retrieve transport config from environment variables
+ * Parses the transport declarations out of `LOGGER_TRANSPORTS`, expanding
+ * `%name` and `%version` first.
+ *
+ * @remarks
+ * An unset variable yields an empty array, which the {@link Logger} treats as
+ * console-only rather than as an error — the normal local-development case.
+ * Malformed JSON, by contrast, throws: a config typo should fail loudly at
+ * start-up rather than silently drop a production log destination.
  *
- * @returns {TransportOptions[]}
+ * @returns the declared transports, or an empty array when unset
+ * @throws TypeError if the variable is set but not parseable as JSON
  */
 export declare function transportsConfig(): TransportOptions[];
 /**
- * Returns default metadata, configured by environment variables
+ * Parses the default record metadata out of `LOGGER_METADATA`, expanding `%name`
+ * and `%version` first.
+ *
+ * @remarks
+ * These fields are attached to every record sent to a transport — a source tag,
+ * an environment name, a hostname — and are what makes records from several
+ * services distinguishable at the collector. Console output is unaffected.
  *
- * @returns {JsonObject}
+ * @returns the parsed metadata, or an empty object when unset
+ * @throws TypeError if the variable is set but not parseable as JSON
  */
 export declare function defaultMetadata(): JsonObject;

package/src/helpers/env.js

@@ -1,30 +1,64 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pkg = pkg;
-exports.transportsConfig = transportsConfig;
-exports.defaultMetadata = defaultMetadata;
-const path_1 = require("path");
-const fs_1 = require("fs");
+/*!
+ * I'm Queue Software Project
+ * Copyright (C) 2025  imqueue.com <support@imqueue.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * If you want to use this code in a closed source (commercial) project, you can
+ * purchase a proprietary commercial license. Please contact us at
+ * <support@imqueue.com> to get commercial licensing options.
+ */
+import {} from '../types.js';
+import { resolve } from 'path';
+import { existsSync as exists, readFileSync } from 'fs';
+import {} from '../TransportOptions.js';
 const RX_NAME = /%name/g;
 const RX_VERSION = /%version/g;
 /**
- * Retrieve package name and version from package.json of running service
+ * Reads the running service's own name and version, used to expand the `%name`
+ * and `%version` placeholders in the logger environment variables.
+ *
+ * @remarks
+ * Resolved from `package.json` in the process's CURRENT WORKING DIRECTORY, not
+ * from this package's location. A service started from a different directory
+ * therefore reports whatever it finds there, and one started somewhere with no
+ * `package.json` falls back to `{ name: 'logger', version: '' }` rather than
+ * failing.
  *
- * @returns {name: string, value: string} - return package name and version
+ * @returns the service name and version, or the fallback pair
  */
-function pkg() {
-    const pkgPath = (0, path_1.resolve)(process.cwd(), 'package.json');
-    const { name, version } = (0, fs_1.existsSync)(pkgPath)
-        ? require(pkgPath)
+export function pkg() {
+    const pkgPath = resolve(process.cwd(), 'package.json');
+    const { name, version } = exists(pkgPath)
+        ? JSON.parse(readFileSync(pkgPath, 'utf8'))
         : { name: 'logger', version: '' };
     return { name, version };
 }
 /**
- * Used for retrieve transport config from environment variables
+ * Parses the transport declarations out of `LOGGER_TRANSPORTS`, expanding
+ * `%name` and `%version` first.
  *
- * @returns {TransportOptions[]}
+ * @remarks
+ * An unset variable yields an empty array, which the {@link Logger} treats as
+ * console-only rather than as an error — the normal local-development case.
+ * Malformed JSON, by contrast, throws: a config typo should fail loudly at
+ * start-up rather than silently drop a production log destination.
+ *
+ * @returns the declared transports, or an empty array when unset
+ * @throws TypeError if the variable is set but not parseable as JSON
  */
-function transportsConfig() {
+export function transportsConfig() {
     const { name, version } = pkg();
     try {
         return JSON.parse((process.env.LOGGER_TRANSPORTS || '[]')
@@ -36,11 +70,18 @@ function transportsConfig() {
     }
 }
 /**
- * Returns default metadata, configured by environment variables
+ * Parses the default record metadata out of `LOGGER_METADATA`, expanding `%name`
+ * and `%version` first.
+ *
+ * @remarks
+ * These fields are attached to every record sent to a transport — a source tag,
+ * an environment name, a hostname — and are what makes records from several
+ * services distinguishable at the collector. Console output is unaffected.
  *
- * @returns {JsonObject}
+ * @returns the parsed metadata, or an empty object when unset
+ * @throws TypeError if the variable is set but not parseable as JSON
  */
-function defaultMetadata() {
+export function defaultMetadata() {
     const { name, version } = pkg();
     try {
         return JSON.parse((process.env.LOGGER_METADATA || '{}')

package/src/helpers/index.d.ts

@@ -19,6 +19,6 @@
  * purchase a proprietary commercial license. Please contact us at
  * <support@imqueue.com> to get commercial licensing options.
  */
-export * from './env';
-export * from './message';
-export * from './transport';
+export * from './env.js';
+export * from './message.js';
+export * from './transport.js';

package/src/helpers/index.js

@@ -1,19 +1,3 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
 /*!
  * I'm Queue Software Project
  * Copyright (C) 2025  imqueue.com <support@imqueue.com>
@@ -35,7 +19,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * purchase a proprietary commercial license. Please contact us at
  * <support@imqueue.com> to get commercial licensing options.
  */
-__exportStar(require("./env"), exports);
-__exportStar(require("./message"), exports);
-__exportStar(require("./transport"), exports);
+export * from './env.js';
+export * from './message.js';
+export * from './transport.js';
 //# sourceMappingURL=index.js.map

package/src/helpers/message.d.ts

@@ -1,7 +1,13 @@
 /**
- * Format message like console log
+ * Renders `console.log`-style arguments into the single string a transport
+ * record needs, applying `util.format` so `%s`/`%d`/`%j` placeholders and object
+ * inspection behave exactly as they do on the console.
  *
- * @param {...*[]} args
- * @returns {string}
+ * @remarks
+ * MUTATES the array it is given — the first element is shifted off to serve as
+ * the format string. Pass a copy if you need the original afterwards.
+ *
+ * @param args - the logging arguments, first one treated as the format string
+ * @returns the formatted message
  */
 export declare function buildMessage(args: any[]): string;

package/src/helpers/message.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildMessage = buildMessage;
 /*!
  * I'm Queue Software Project
  * Copyright (C) 2025  imqueue.com <support@imqueue.com>
@@ -22,14 +19,20 @@ exports.buildMessage = buildMessage;
  * purchase a proprietary commercial license. Please contact us at
  * <support@imqueue.com> to get commercial licensing options.
  */
-const util_1 = require("util");
+import { format } from 'util';
 /**
- * Format message like console log
+ * Renders `console.log`-style arguments into the single string a transport
+ * record needs, applying `util.format` so `%s`/`%d`/`%j` placeholders and object
+ * inspection behave exactly as they do on the console.
  *
- * @param {...*[]} args
- * @returns {string}
+ * @remarks
+ * MUTATES the array it is given — the first element is shifted off to serve as
+ * the format string. Pass a copy if you need the original afterwards.
+ *
+ * @param args - the logging arguments, first one treated as the format string
+ * @returns the formatted message
  */
-function buildMessage(args) {
-    return (0, util_1.format)(args.shift(), ...args);
+export function buildMessage(args) {
+    return format(args.shift(), ...args);
 }
 //# sourceMappingURL=message.js.map

package/src/helpers/transport.d.ts

@@ -1,11 +1,16 @@
-import * as Transport from 'winston-transport';
-import { FileTransportOptions, HttpTransportOptions } from 'winston/lib/winston/transports';
+import type Transport from 'winston-transport';
+import type { FileTransportOptions, HttpTransportOptions } from 'winston/lib/winston/transports/index.js';
 /**
- * Used for get configured transport by type
+ * Constructs a winston transport of the named type.
  *
- * @param {string} type - transport type
- * @param {FileTransportOptions | HttpTransportOptions} options -
- *   options for configure transport
- * @returns {Transport}
+ * @remarks
+ * Only `'file'` and `'http'` are supported. Anything else returns nothing —
+ * despite the declared return type, which is a `Transport` cast rather than a
+ * guarantee. {@link Logger} checks for that and reports the offending type; a
+ * direct caller must check too.
+ *
+ * @param type - `'file'` or `'http'`
+ * @param options - options for the winston transport constructor
+ * @returns the transport, or nothing if the type is not recognised
  */
 export declare function getTransport(type: string, options: FileTransportOptions | HttpTransportOptions): Transport;

package/src/helpers/transport.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTransport = getTransport;
 /*!
  * I'm Queue Software Project
  * Copyright (C) 2025  imqueue.com <support@imqueue.com>
@@ -22,22 +19,27 @@ exports.getTransport = getTransport;
  * purchase a proprietary commercial license. Please contact us at
  * <support@imqueue.com> to get commercial licensing options.
  */
-const winston_1 = require("winston");
+import { transports } from 'winston';
 /**
- * Used for get configured transport by type
+ * Constructs a winston transport of the named type.
  *
- * @param {string} type - transport type
- * @param {FileTransportOptions | HttpTransportOptions} options -
- *   options for configure transport
- * @returns {Transport}
+ * @remarks
+ * Only `'file'` and `'http'` are supported. Anything else returns nothing —
+ * despite the declared return type, which is a `Transport` cast rather than a
+ * guarantee. {@link Logger} checks for that and reports the offending type; a
+ * direct caller must check too.
+ *
+ * @param type - `'file'` or `'http'`
+ * @param options - options for the winston transport constructor
+ * @returns the transport, or nothing if the type is not recognised
  */
-function getTransport(type, options) {
+export function getTransport(type, options) {
     let transportInstance = null;
     if (type === 'file') {
-        transportInstance = new winston_1.transports.File(options);
+        transportInstance = new transports.File(options);
     }
     else if (type === 'http') {
-        transportInstance = new winston_1.transports.Http(options);
+        transportInstance = new transports.Http(options);
     }
     return transportInstance;
 }

package/src/index.d.ts

@@ -19,6 +19,7 @@
  * purchase a proprietary commercial license. Please contact us at
  * <support@imqueue.com> to get commercial licensing options.
  */
-export * from './helpers';
-export * from './TransportOptions';
-export * from './Logger';
+export * from './types.js';
+export * from './helpers/index.js';
+export * from './TransportOptions.js';
+export * from './Logger.js';