@kubb/agent 4.29.1 → 4.31.1

package/.output/server/node_modules/@kubb/react-fabric/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/react-fabric",
-  "version": "0.13.1",
+  "version": "0.13.3",
   "description": "React integration for Kubb's fabric - JSX runtime and component-based code generation with React reconciler for building type-safe generators",
   "keywords": [
     "react",
@@ -92,7 +92,8 @@
     "*.d.cts",
     "!*.map",
     "!/**/**.test.**",
-    "!/**/__tests__/**"
+    "!/**/__tests__/**",
+    "!/**/__snapshots__/**"
   ],
   "size-limit": [
     {
@@ -105,7 +106,7 @@
     "react-devtools-core": "6.1.5",
     "remeda": "^2.33.6",
     "ws": "8.18.0",
-    "@kubb/fabric-core": "0.13.1"
+    "@kubb/fabric-core": "0.13.3"
   },
   "devDependencies": {
     "@types/react": "^19.2.14",

package/.output/server/node_modules/@logtail/core/dist/cjs/base.js

@@ -0,0 +1,339 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("@logtail/types");
+const tools_1 = require("@logtail/tools");
+const serialize_error_1 = require("serialize-error");
+// Set default options for Logtail
+const defaultOptions = {
+    // Default sync endpoint (protocol + domain)
+    endpoint: "https://in.logs.betterstack.com",
+    // Maximum number of logs to sync in a single request to Better Stack
+    batchSize: 1000,
+    // Size of logs (in KiB) to trigger sync to Better Stack (0 to disable)
+    batchSizeKiB: 0,
+    // Max interval (in milliseconds) before a batch of logs proceeds to syncing
+    batchInterval: 1000,
+    // Maximum number of times to retry a failed sync request
+    retryCount: 3,
+    // Minimum number of milliseconds to wait before retrying a failed sync request
+    retryBackoff: 100,
+    // Maximum number of sync requests to make concurrently
+    syncMax: 5,
+    // Maximum number of sync requests that can be queued (-1 for unlimited queue)
+    syncQueuedMax: 100,
+    // Length of the checked window for logs burst protection in milliseconds (0 to disable)
+    burstProtectionMilliseconds: 5000,
+    // Maximum number of accepted logs in the specified time window (0 to disable)
+    burstProtectionMax: 10000,
+    // If true, errors when sending logs will be ignored
+    // Has precedence over throwExceptions
+    ignoreExceptions: false,
+    // If true, errors when sending logs will result in a thrown exception
+    throwExceptions: false,
+    // Maximum depth (number of attribute levels) of a context object
+    contextObjectMaxDepth: 50,
+    // Produce a warn log when context object max depth is reached
+    contextObjectMaxDepthWarn: true,
+    // Produce a warning when circular reference is found in context object
+    contextObjectCircularRefWarn: true,
+    // If true, all logs will be sent to standard console output functions (console.info, console.warn, ...)
+    sendLogsToConsoleOutput: false,
+    // If true, all logs will be sent to Better Stack
+    sendLogsToBetterStack: true,
+    // Function to be used to calculate size of logs in bytes (to evaluate batchSizeLimitKiB)
+    calculateLogSizeBytes: tools_1.calculateJsonLogSizeBytes,
+};
+/**
+ * Logtail core class for logging to the Better Stack service
+ */
+class Logtail {
+    /* CONSTRUCTOR */
+    /**
+     * Initializes a new Logtail instance
+     *
+     * @param sourceToken: string - Private source token for logging to Better Stack
+     * @param options?: ILogtailOptions - Optionally specify Logtail options
+     */
+    constructor(sourceToken, options) {
+        // Middleware
+        this._middleware = [];
+        // Number of logs logged
+        this._countLogged = 0;
+        // Number of logs successfully synced with Logtail
+        this._countSynced = 0;
+        // Number of logs that failed to be synced to Logtail
+        this._countDropped = 0;
+        // First, check we have a valid source token
+        if (typeof sourceToken !== "string" || sourceToken === "") {
+            throw new Error("Logtail source token missing");
+        }
+        // Store the source token, to use for syncing with Better Stack
+        this._sourceToken = sourceToken;
+        // Merge default and user options
+        this._options = Object.assign(Object.assign({}, defaultOptions), options);
+        // Create a throttler, for sync operations
+        const throttle = (0, tools_1.makeThrottle)(this._options.syncMax, this._options.syncQueuedMax);
+        // Sync after throttling
+        const throttler = throttle((logs) => {
+            return this._sync(logs);
+        });
+        // Burst protection for logging
+        this._logBurstProtection = (0, tools_1.makeBurstProtection)(this._options.burstProtectionMilliseconds, this._options.burstProtectionMax, "Logging");
+        this.log = this._logBurstProtection(this.log.bind(this));
+        // Create a batcher, for aggregating logs by buffer size/interval
+        const batcher = (0, tools_1.makeBatch)(this._options.batchSize, this._options.batchInterval, this._options.retryCount, this._options.retryBackoff, this._options.batchSizeKiB * 1024, this._options.calculateLogSizeBytes);
+        this._batch = batcher.initPusher((logs) => {
+            return throttler(logs);
+        });
+        this._flush = batcher.flush;
+    }
+    /* PUBLIC METHODS */
+    /**
+     * Flush batched logs to Logtail
+     */
+    async flush() {
+        return this._flush();
+    }
+    /**
+     * Number of entries logged
+     *
+     * @returns number
+     */
+    get logged() {
+        return this._countLogged;
+    }
+    /**
+     * Number of log entries synced with Better Stack
+     *
+     * @returns number
+     */
+    get synced() {
+        return this._countSynced;
+    }
+    /**
+     * Number of entries dropped
+     *
+     * @returns number
+     */
+    get dropped() {
+        return this._countDropped;
+    }
+    /**
+     * Log an entry, to be synced with Better Stack
+     *
+     * @param message: string - Log message
+     * @param level (LogLevel) - Level to log at (debug|info|warn|error)
+     * @param context: (Context) - Context (optional)
+     * @returns Promise<ILogtailLog> after syncing
+     */
+    async log(message, level = types_1.LogLevel.Info, context = {}) {
+        // Wrap context in an object, if it's not already
+        if (typeof context !== "object") {
+            const wrappedContext = { extra: context };
+            context = wrappedContext;
+        }
+        if (context instanceof Error) {
+            const wrappedContext = { error: context };
+            context = wrappedContext;
+        }
+        if (this._options.sendLogsToConsoleOutput) {
+            switch (level) {
+                case "debug":
+                    console.debug(message, context);
+                    break;
+                case "info":
+                    console.info(message, context);
+                    break;
+                case "warn":
+                    console.warn(message, context);
+                    break;
+                case "error":
+                    console.error(message, context);
+                    break;
+                default:
+                    console.log(`[${level.toUpperCase()}]`, message, context);
+                    break;
+            }
+        }
+        // Check that we have a sync function
+        if (typeof this._sync !== "function") {
+            throw new Error("No Logtail logger sync function provided");
+        }
+        // Increment log count
+        this._countLogged++;
+        // Start building the log message
+        let log = Object.assign(Object.assign({ 
+            // Implicit date timestamp
+            dt: new Date(), 
+            // Explicit level
+            level }, context), (message instanceof Error ? (0, serialize_error_1.serializeError)(message) : { message }));
+        let transformedLog = log;
+        for (const middleware of this._middleware) {
+            let newTransformedLog = await middleware(transformedLog);
+            if (newTransformedLog == null) {
+                // Don't push the log if it was filtered out in a middleware
+                return transformedLog;
+            }
+            transformedLog = newTransformedLog;
+        }
+        // Manually serialize the log data
+        transformedLog = this.serialize(transformedLog, this._options.contextObjectMaxDepth);
+        if (!this._options.sendLogsToBetterStack) {
+            // Return the resulting log before sending it
+            return transformedLog;
+        }
+        try {
+            // Push the log through the batcher, and sync
+            await this._batch(transformedLog);
+            // Increment sync count
+            this._countSynced++;
+        }
+        catch (e) {
+            // Increment dropped count
+            this._countDropped++;
+            // Catch any errors - re-throw if `ignoreExceptions` == false
+            if (!this._options.ignoreExceptions) {
+                if (this._options.throwExceptions) {
+                    throw e;
+                }
+                else {
+                    // Output to console
+                    console.error(e);
+                }
+            }
+        }
+        // Return the resulting log
+        return transformedLog;
+    }
+    serialize(value, maxDepth, visitedObjects = new WeakSet()) {
+        if (value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
+            return value;
+        }
+        else if (value instanceof Date) {
+            // Date instances can be invalid & toISOString() will fail
+            if (isNaN(value.getTime())) {
+                return value.toString();
+            }
+            return value.toISOString();
+        }
+        else if (value instanceof Error) {
+            return (0, serialize_error_1.serializeError)(value);
+        }
+        else if ((typeof value === "object" || Array.isArray(value)) && (maxDepth < 1 || visitedObjects.has(value))) {
+            if (visitedObjects.has(value)) {
+                if (this._options.contextObjectCircularRefWarn) {
+                    console.warn(`[Logtail] Found a circular reference when serializing logs. Please do not use circular references in your logs.`);
+                }
+                return "<omitted circular reference>";
+            }
+            if (this._options.contextObjectMaxDepthWarn) {
+                console.warn(`[Logtail] Max depth of ${this._options.contextObjectMaxDepth} reached when serializing logs. Please do not use excessive object depth in your logs.`);
+            }
+            return `<omitted context beyond configured max depth: ${this._options.contextObjectMaxDepth}>`;
+        }
+        else if (Array.isArray(value)) {
+            visitedObjects.add(value);
+            const serializedArray = value.map((item) => this.serialize(item, maxDepth - 1, visitedObjects));
+            visitedObjects.delete(value);
+            return serializedArray;
+        }
+        else if (typeof value === "object") {
+            const serializedObject = {};
+            visitedObjects.add(value);
+            Object.entries(value).forEach((item) => {
+                const key = item[0];
+                const value = item[1];
+                const serializedValue = this.serialize(value, maxDepth - 1, visitedObjects);
+                if (serializedValue !== undefined) {
+                    serializedObject[key] = serializedValue;
+                }
+            });
+            visitedObjects.delete(value);
+            return serializedObject;
+        }
+        else if (typeof value === "undefined") {
+            return undefined;
+        }
+        else {
+            return `<omitted unserializable ${typeof value}>`;
+        }
+    }
+    /**
+     *
+     * Debug level log, to be synced with Better Stack
+     *
+     * @param message: string - Log message
+     * @param context: (Pick<ILogtailLog, "context">) - Context (optional)
+     * @returns Promise<ILogtailLog> after syncing
+     */
+    async debug(message, context = {}) {
+        return this.log(message, types_1.LogLevel.Debug, context);
+    }
+    /**
+     *
+     * Info level log, to be synced with Better Stack
+     *
+     * @param message: string - Log message
+     * @param context: (Pick<ILogtailLog, "context">) - Context (optional)
+     * @returns Promise<ILogtailLog> after syncing
+     */
+    async info(message, context = {}) {
+        return this.log(message, types_1.LogLevel.Info, context);
+    }
+    /**
+     *
+     * Warning level log, to be synced with Better Stack
+     *
+     * @param message: string - Log message
+     * @param context: (Pick<ILogtailLog, "context">) - Context (optional)
+     * @returns Promise<ILogtailLog> after syncing
+     */
+    async warn(message, context = {}) {
+        return this.log(message, types_1.LogLevel.Warn, context);
+    }
+    /**
+     *
+     * Warning level log, to be synced with Better Stack
+     *
+     * @param message: string - Log message
+     * @param context: (Pick<ILogtailLog, "context">) - Context (optional)
+     * @returns Promise<ILogtailLog> after syncing
+     */
+    async error(message, context = {}) {
+        return this.log(message, types_1.LogLevel.Error, context);
+    }
+    /**
+     * Sets the sync method - i.e. the final step in the pipeline to get logs
+     * over to Better Stack
+     *
+     * @param fn - Pipeline function to use as sync method
+     */
+    setSync(fn) {
+        this._sync = fn;
+    }
+    /**
+     * Add a middleware function to the logging pipeline
+     *
+     * @param fn - Function to add to the log pipeline
+     * @returns void
+     */
+    use(fn) {
+        this._middleware.push(fn);
+    }
+    /**
+     * Remove a function from the pipeline
+     *
+     * @param fn - Pipeline function
+     * @returns void
+     */
+    remove(fn) {
+        this._middleware = this._middleware.filter((p) => p !== fn);
+    }
+}
+class default_1 extends Logtail {
+    async log(message, level = types_1.LogLevel.Info, context = {}) {
+        return super.log(message, level, context);
+    }
+}
+exports.default = default_1;
+//# sourceMappingURL=base.js.map

package/.output/server/node_modules/@logtail/core/dist/cjs/index.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Base = void 0;
+const base_1 = __importDefault(require("./base"));
+exports.Base = base_1.default;
+//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@logtail/core/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@logtail/core",
+  "version": "0.5.6",
+  "description": "Better Stack logging core (formerly Logtail)",
+  "keywords": [
+    "Better Stack",
+    "Logtail",
+    "logger",
+    "logging"
+  ],
+  "author": "Better Stack <hello@betterstack.com>",
+  "homepage": "https://github.com/logtail/logtail-js/tree/master/packages/core#readme",
+  "license": "ISC",
+  "main": "dist/cjs/index.js",
+  "module": "dist/es6/index.js",
+  "types": "dist/es6/index.d.ts",
+  "files": [
+    "src",
+    "dist"
+  ],
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/logtail/logtail-js.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build:cjs": "tsc",
+    "build:es6": "tsc -p tsconfig.es6.json",
+    "build": "run-p build:*",
+    "prepublishOnly": "npm run build",
+    "test": "echo \"Error: run tests from root\" && exit 1"
+  },
+  "bugs": {
+    "url": "https://github.com/logtail/logtail-js/issues"
+  },
+  "dependencies": {
+    "@logtail/tools": "^0.5.6",
+    "@logtail/types": "^0.5.6",
+    "serialize-error": "8.1.0"
+  },
+  "gitHead": "6901c2b90af7cf9dda3e7c8be7c145d4d83e72a8"
+}

package/.output/server/node_modules/@logtail/node/dist/cjs/context.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStackContext = getStackContext;
+const path_1 = require("path");
+const stack_trace_1 = __importDefault(require("stack-trace"));
+const mainFile = mainFileName();
+/**
+ * Determines the file name and the line number from which the log
+ * was initiated (if we're able to tell).
+ *
+ * @returns Context The caller's filename and the line number
+ */
+function getStackContext(logtail, stackContextHint) {
+    const stackFrame = getCallingFrame(logtail, stackContextHint);
+    if (stackFrame === null)
+        return {};
+    return {
+        context: {
+            runtime: {
+                file: relativeToMainModule(stackFrame.getFileName()),
+                type: stackFrame.getTypeName(),
+                method: stackFrame.getMethodName(),
+                function: stackFrame.getFunctionName(),
+                line: stackFrame.getLineNumber(),
+                column: stackFrame.getColumnNumber(),
+            },
+            system: {
+                pid: process.pid,
+                main_file: mainFile,
+            },
+        },
+    };
+}
+function getCallingFrame(logtail, stackContextHint) {
+    for (let fn of [logtail.warn, logtail.error, logtail.info, logtail.debug, logtail.log]) {
+        const stack = stack_trace_1.default.get(fn);
+        if ((stack === null || stack === void 0 ? void 0 : stack.length) > 0)
+            return getRelevantStackFrame(stack, stackContextHint);
+    }
+    return null;
+}
+function getRelevantStackFrame(frames, stackContextHint) {
+    if (stackContextHint) {
+        frames.reverse();
+        let index = frames.findIndex((frame) => {
+            var _a;
+            return (((_a = frame.getFileName()) === null || _a === void 0 ? void 0 : _a.includes(stackContextHint.fileName)) &&
+                (stackContextHint.methodNames.includes(frame.getMethodName()) ||
+                    stackContextHint.methodNames.includes(frame.getFunctionName())));
+        });
+        if (index > 0) {
+            return frames[index - 1];
+        }
+        if (stackContextHint.required) {
+            return null;
+        }
+        return frames[frames.length - 1];
+    }
+    return frames[0];
+}
+function relativeToMainModule(fileName) {
+    if (typeof fileName !== "string") {
+        return null;
+    }
+    else if (fileName.startsWith("file:/")) {
+        const url = new URL(fileName);
+        return url.pathname;
+    }
+    else {
+        const rootPath = (0, path_1.dirname)(mainFileName());
+        return (0, path_1.relative)(rootPath, fileName);
+    }
+}
+function mainFileName() {
+    let argv = process === null || process === void 0 ? void 0 : process.argv;
+    if (argv === undefined)
+        return "";
+    // return first js file argument - arg ending in .js
+    for (const arg of argv) {
+        if (typeof arg !== "string" || arg.startsWith("-")) {
+            // break on first option
+            break;
+        }
+        if (arg.endsWith(".js")) {
+            return arg;
+        }
+    }
+    return "";
+}
+//# sourceMappingURL=context.js.map

package/.output/server/node_modules/@logtail/node/dist/cjs/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logtail = void 0;
+const node_1 = require("./node");
+Object.defineProperty(exports, "Logtail", { enumerable: true, get: function () { return node_1.Node; } });
+//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@logtail/node/dist/cjs/node.js

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Node = void 0;
+const msgpack_1 = require("@msgpack/msgpack");
+const node_http_1 = __importDefault(require("node:http"));
+const node_https_1 = __importDefault(require("node:https"));
+const node_zlib_1 = __importDefault(require("node:zlib"));
+const core_1 = require("@logtail/core");
+const context_1 = require("./context");
+class Node extends core_1.Base {
+    constructor(sourceToken, options) {
+        options = Object.assign({ timeout: 30000 }, options);
+        super(sourceToken, options);
+        const agent = this.createAgent();
+        // Sync function
+        const sync = async (logs) => {
+            const nodeOptions = this._options;
+            const request = this.getHttpModule().request(nodeOptions.endpoint, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/msgpack",
+                    "Content-Encoding": "gzip",
+                    Authorization: `Bearer ${this._sourceToken}`,
+                    "User-Agent": "logtail-js(node)",
+                },
+                agent,
+                timeout: nodeOptions.timeout > 0 ? nodeOptions.timeout : undefined,
+            });
+            const response = await new Promise((resolve, reject) => {
+                // Setup timeout handler if timeout is configured
+                if (nodeOptions.timeout > 0) {
+                    request.on("timeout", () => {
+                        request.destroy();
+                        reject(new Error(`Request timeout after ${nodeOptions.timeout}ms`));
+                    });
+                }
+                request.on("response", resolve);
+                request.on("error", reject);
+                // Compress the logs using gzip
+                node_zlib_1.default.gzip(this.encodeAsMsgpack(logs), (err, compressedData) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    request.write(compressedData);
+                    request.end();
+                });
+            });
+            if (response.statusCode && response.statusCode >= 200 && response.statusCode < 300) {
+                return logs;
+            }
+            throw new Error(response.statusMessage);
+        };
+        // Set the throttled sync function
+        this.setSync(sync);
+    }
+    /**
+     * Override `Base` log to enable Node.js streaming
+     *
+     * @param message: string - Log message
+     * @param level (LogLevel) - Level to log at (debug|info|warn|error)
+     * @param context: (Context) - Log context for passing structured data
+     * @param stackContextHint: (StackContextHint|null) - Info about which methods to consider as origin in context.runtime
+     * @returns Promise<ILogtailLog> after syncing
+     */
+    async log(message, level, context = {}, stackContextHint) {
+        // Process/sync the log, per `Base` logic
+        context = Object.assign(Object.assign({}, (0, context_1.getStackContext)(this, stackContextHint)), context);
+        const processedLog = await super.log(message, level, context);
+        // Push the processed log to the stream, for piping
+        if (this._writeStream) {
+            this._writeStream.write(JSON.stringify(processedLog) + "\n");
+        }
+        // Return the transformed log
+        return processedLog;
+    }
+    /**
+     * Pipe JSON stringified `ILogtailLog` to a stream after syncing
+     *
+     * @param stream - Writable|Duplex stream
+     */
+    pipe(stream) {
+        this._writeStream = stream;
+        return stream;
+    }
+    encodeAsMsgpack(logs) {
+        const encoded = (0, msgpack_1.encode)(logs);
+        const buffer = Buffer.from(encoded.buffer, encoded.byteOffset, encoded.byteLength);
+        return buffer;
+    }
+    createAgent() {
+        const nodeOptions = this._options;
+        const family = nodeOptions.useIPv6 ? 6 : 4;
+        return new (this.getHttpModule().Agent)({
+            family,
+        });
+    }
+    getHttpModule() {
+        return this._options.endpoint.startsWith("https") ? node_https_1.default : node_http_1.default;
+    }
+}
+exports.Node = Node;
+//# sourceMappingURL=node.js.map

package/.output/server/node_modules/@logtail/node/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@logtail/node",
+  "version": "0.5.6",
+  "description": "Better Stack Node.js logger (formerly Logtail)",
+  "keywords": [
+    "Better Stack",
+    "Logtail",
+    "logger",
+    "logging",
+    "Node"
+  ],
+  "author": "Better Stack <hello@betterstack.com>",
+  "homepage": "https://github.com/logtail/logtail-js/tree/master/packages/node#readme",
+  "license": "ISC",
+  "main": "dist/cjs/index.js",
+  "module": "dist/es6/index.js",
+  "types": "dist/es6/index.d.ts",
+  "files": [
+    "src",
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/logtail/logtail-js.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build:cjs": "tsc",
+    "build:es6": "tsc -p tsconfig.es6.json",
+    "build": "run-p build:*",
+    "prepublishOnly": "npm run build",
+    "test": "echo \"Error: run tests from root\" && exit 1"
+  },
+  "bugs": {
+    "url": "https://github.com/logtail/logtail-js/issues"
+  },
+  "devDependencies": {
+    "@types/fetch-mock": "^7.3.1",
+    "@types/nock": "^11.1.0",
+    "nock": "^14.0.1"
+  },
+  "dependencies": {
+    "@logtail/core": "^0.5.6",
+    "@logtail/types": "^0.5.6",
+    "@msgpack/msgpack": "^2.5.1",
+    "@types/stack-trace": "^0.0.33",
+    "minimatch": "^9.0.5",
+    "stack-trace": "0.0.10"
+  },
+  "gitHead": "6901c2b90af7cf9dda3e7c8be7c145d4d83e72a8"
+}