update Mokapi typings to v0.29.0

Author: marle3003

types/mokapi/faker.d.ts

@@ -13,9 +13,13 @@
 export function fake(schema: Schema | JSONSchema): any;
 
 /**
- * Retrieves a node from the faker tree by its name.
+ * Retrieves a node from the faker tree by its name or path.
  *
- * @param name name - The name of the node to find.
+ * A node can be referenced either by its simple name (e.g. `"name"`) or by a path
+ * that describes its location in the tree (e.g. `"/person/name"` for an absolute
+ * path from the root, or `"middle/name"` for a relative path).
+ *
+ * @param name name - The name or path of the node to find.
  * @returns The matching {@link Node} from the faker tree.
  *
  * @example

types/mokapi/http.d.ts

@@ -86,13 +86,105 @@ export function del(url: string, body?: JSONValue, args?: Args): Response;
  */
 export function options(url: string, body?: JSONValue, args?: Args): Response;
 
+/**
+ * Sends an HTTP request and returns a Promise resolving to the response.
+ *
+ * @param {string} url - The URL to request.
+ * @param {FetchOptions} opts - Optional fetch configuration.
+ * @returns {Promise<Response>} A Promise that resolves with the response.
+ *
+ * @example
+ * // Simple GET request
+ * const res = await fetch('https://foo.bar/api');
+ * const data = await res.json();
+ *
+ * @example
+ * // POST request with JSON body
+ * const res = await fetch('https://foo.bar/api', {
+ *   method: 'POST',
+ *   headers: { 'Content-Type': 'application/json' },
+ *   body: { name: 'Alice' }
+ * });
+ *
+ * @example
+ * // Request with timeout and redirect settings
+ * const res = await fetch('https://foo.bar/api', {
+ *   timeout: '5s',
+ *   maxRedirects: 2
+ * });
+ */
+export function fetch(url: string, opts?: FetchOptions): Promise<Response>
+
 /**
  * Request arguments.
  * Used to add headers to a request.
  */
 export interface Args {
     /** Request headers. */
-    header?: { [name: string]: string };
+    headers?: { [name: string]: string };
+    /**
+     * The number of redirects to follow for this request.
+     * @default 5
+     **/
+    maxRedirects?: number
+    /**
+     * Maximum time to wait for the request to complete. Default
+     * timeout is 60 seconds ("60s"). The type can also be a number, in which
+     * case Mokapi interprets it as milliseconds
+     * @example
+     * const res = get(url, { timeout: '5m' })
+     */
+    timeout?: number | string
+}
+
+/**
+ * Options for the {@link fetch} function.
+ */
+export interface FetchOptions {
+    /**
+     * HTTP method to use for the request.
+     * @default "GET"
+     * @example
+     * const res = await fetch(url, { method: 'POST' });
+     */
+    method?: string
+
+    /**
+     * The body of the request, such as a string or object.
+     * @example
+     * const res = await fetch(url, { body: JSON.stringify({ name: 'Alice' }) });
+     */
+    body?: any
+
+    /**
+     * Request headers.
+     * @example
+     * const res = await fetch(url, {
+     *   headers: { 'Authorization': 'Bearer token123' }
+     * });
+     */
+    headers?: { [name: string]: string };
+
+    /**
+     * The number of redirects to follow for this request.
+     * @default 5
+     * @example
+     * const res = await fetch(url, { maxRedirects: 1 });
+     **/
+    maxRedirects?: number
+
+    /**
+     * Maximum time to wait for the request to complete. Default
+     * timeout is 60 seconds ("60s"). The type can also be a number, in which
+     * case Mokapi interprets it as milliseconds
+     * @default "60s"
+     * @example
+     * const res = get(url, { timeout: '5m' })
+     * @example
+     * // Timeout as milliseconds
+     * const res = await fetch(url, { timeout: 3000 });
+     */
+    timeout?: number | string
 }
 
 /**

types/mokapi/index.d.ts

@@ -130,7 +130,10 @@ export type HttpEventHandler = (request: HttpRequest, response: HttpResponse) =>
  * https://mokapi.io/docs/javascript-api/mokapi/eventhandler/httprequest
  */
 export interface HttpRequest {
-    /** Request method. */
+    /**
+     * Request method.
+     * @example GET
+     * */
     readonly method: string;
 
     /** Represents a parsed URL. */
@@ -151,6 +154,9 @@ export interface HttpRequest {
     /** Object contains cookie parameters specified by OpenAPI cookie parameters. */
     readonly cookie: { [key: string]: any };
 
+    /** Object contains querystring parameters specified by OpenAPI querystring parameters. */
+    readonly querystring: any;
+
     /** Path value specified by the OpenAPI path */
     readonly key: string;
 
@@ -406,13 +412,33 @@ export type DateLayout =
     | "RFC3339Nano";
 
 /**
- * Additional event arguments
+ * EventArgs object contains additional arguments for an event handler.
+ * https://mokapi.io/docs/javascript-api/mokapi/on
+ *
+ * Use this to customize how the event appears in the dashboard or to control tracking.
+ *
+ * @example
+ * export default function() {
+ *   on('http', function(req, res) {
+ *     res.data = { message: "tracked event" }
+ *   }, {
+ *     tags: { feature: 'beta', owner: 'team-a' },
+ *     track: true
+ *   })
+ * }
  */
 export interface EventArgs {
     /**
-     * Adds or overrides existing tags used in dashboard
+     * Optional key-value pairs used to label the event in the dashboard.
      */
     tags?: { [key: string]: string };
+
+    /**
+     * Set to `true` to enable tracking of this event handler in the dashboard.
+     * If omitted, Mokapi automatically checks whether the response object has
+     * been modified and tracks the handler only if a change is detected.
+     */
+    track?: boolean;
 }
 
 /**
@@ -510,3 +536,99 @@ export function patch(target: any, patch: any): any;
  * // result: { name: "foo" }
  */
 export const Delete: unique symbol;
+
+export interface SharedMemory {
+    /**
+     * Returns the value associated with the given key.
+     * @param key The key to retrieve.
+     * @returns The stored value, or `undefined` if not found.
+     */
+    get(key: string): any
+
+    /**
+     * Sets a value for the given key.
+     * If the key already exists, its value will be replaced.
+     * @param key The key to store the value under.
+     * @param value The value to store.
+     */
+    set(key: string, value: any): void
+
+    /**
+     * Updates a value atomically using an updater function.
+     * The current value is passed into the updater function.
+     * The returned value is stored and also returned by this method.
+     *
+     * Example:
+     * ```js
+     * mokapi.shared.update("requests", count => (count ?? 0) + 1)
+     * ```
+     *
+     * @param key The key to update.
+     * @param updater Function that receives the current value and returns the new value.
+     * @returns The new value after update.
+     */
+    update<T = any>(key: string, updater: (value: T | undefined) => T): T
+
+    /**
+     * Checks if the given key exists in shared memory.
+     * @param key The key to check.
+     * @returns `true` if the key exists, otherwise `false`.
+     */
+    has(key: string): boolean
+
+    /**
+     * Removes the specified key and its value from shared memory.
+     * @param key The key to remove.
+     */
+    delete(key: string): void
+
+    /**
+     * Removes all stored entries from shared memory.
+     * Use with caution — this clears all shared state.
+     */
+    clear(): void
+
+    /**
+     * Returns a list of all stored keys.
+     * @returns An array of key names.
+     */
+    keys(): string[]
+
+    /**
+     * Creates or returns a namespaced shared memory store.
+     * Namespaces help avoid key collisions between unrelated scripts.
+     *
+     * Example:
+     * ```js
+     * const petstore = mokapi.shared.namespace("petstore")
+     * petstore.set("sessions", [])
+     * ```
+     *
+     * @param name The namespace identifier.
+     * @returns A `SharedMemory` object scoped to the given namespace.
+     */
+    namespace(name: string): SharedMemory
+}
+
+/**
+ * Shared memory API for Mokapi scripts.
+ *
+ * The `mokapi.shared` object provides a way to persist and share
+ * data between multiple scripts running in the same Mokapi instance.
+ *
+ * Values are stored in memory and shared across all scripts.
+ * This allows you to coordinate state, cache data, or simulate
+ * application-level variables without using global variables.
+ * All values are persisted for the lifetime of the Mokapi process.
+ *
+ * Example:
+ * ```js
+ * // Increment a shared counter
+ * mokapi.shared.update("counter", c => (c ?? 0) + 1)
+ *
+ * // Retrieve the current counter value
+ * const count = mokapi.shared.get("counter")
+ * mokapi.log(`Current counter: ${count}`)
+ * ```
+ */
+export const shared: SharedMemory

types/mokapi/mail.d.ts

@@ -78,4 +78,4 @@ export interface Attachment {
 
     /** File data as binary content */
     data: Uint8Array;
-}
+}

types/mokapi/package.json

@@ -1,7 +1,7 @@
 {
     "private": true,
     "name": "@types/mokapi",
-    "version": "0.20.9999",
+    "version": "0.29.9999",
     "nonNpm": true,
     "nonNpmDescription": "Mokapi",
     "projects": [

types/mokapi/test/http-test.ts

@@ -1,4 +1,4 @@
-import { del, get, head, options, patch, post, put } from "mokapi/http";
+import { del, get, head, options, patch, post, put, fetch } from "mokapi/http";
 
 // @ts-expect-error
 get();
@@ -8,7 +8,10 @@ get("http://foo.bar");
 // @ts-expect-error
 get("", 123);
 get("", {});
-get("", { header: { "Accept": "application/json" } });
+get("", { headers: { "Accept": "application/json" } });
+get("", { maxRedirects: 3 });
+get("http://foo.bar", { timeout: 3000 });
+get("http://foo.bar", { timeout: "3s" });
 
 // @ts-expect-error
 post();
@@ -19,7 +22,10 @@ post("", 123);
 post("", { foo: "bar" });
 // @ts-expect-error
 post("", {}, 123);
-post("", "", { header: { "Accept": "application/json" } });
+post("", "", { headers: { "Accept": "application/json" } });
+post("", undefined, { maxRedirects: 3 });
+post("http://foo.bar", undefined, { timeout: 3000 });
+post("http://foo.bar", undefined, { timeout: "3s" });
 
 // @ts-expect-error
 put();
@@ -30,14 +36,20 @@ put("", 123);
 put("", { foo: "bar" });
 // @ts-expect-error
 put("", {}, 123);
-put("", "", { header: { "Accept": "application/json" } });
+put("", "", { headers: { "Accept": "application/json" } });
+put("", undefined, { maxRedirects: 3 });
+put("http://foo.bar", undefined, { timeout: 3000 });
+put("http://foo.bar", undefined, { timeout: "3s" });
 
 // @ts-expect-error
 head();
 // @ts-expect-error
 head(123);
 head("http://foo.bar");
-head("", { header: { "Accept": "application/json" } });
+head("", { headers: { "Accept": "application/json" } });
+head("", { maxRedirects: 3 });
+head("http://foo.bar", { timeout: 3000 });
+head("http://foo.bar", { timeout: "3s" });
 
 // @ts-expect-error
 patch();
@@ -48,7 +60,10 @@ patch("", 123);
 patch("", { foo: "bar" });
 // @ts-expect-error
 patch("", {}, 123);
-patch("", "", { header: { "Accept": "application/json" } });
+patch("", "", { headers: { "Accept": "application/json" } });
+patch("", undefined, { maxRedirects: 3 });
+patch("http://foo.bar", undefined, { timeout: 3000 });
+patch("http://foo.bar", undefined, { timeout: "3s" });
 
 // @ts-expect-error
 del();
@@ -59,7 +74,10 @@ del("", 123);
 del("", { foo: "bar" });
 // @ts-expect-error
 del("", {}, 123);
-del("", "", { header: { "Accept": "application/json" } });
+del("", "", { headers: { "Accept": "application/json" } });
+del("", undefined, { maxRedirects: 3 });
+del("http://foo.bar", undefined, { timeout: 3000 });
+del("http://foo.bar", undefined, { timeout: "3s" });
 
 // @ts-expect-error
 options();
@@ -70,4 +88,20 @@ options("", 123);
 options("", { foo: "bar" });
 // @ts-expect-error
 options("", {}, 123);
-options("", "", { header: { "Accept": "application/json" } });
+options("", "", { headers: { "Accept": "application/json" } });
+options("", { maxRedirects: 3 });
+options("http://foo.bar", undefined, { timeout: 3000 });
+options("http://foo.bar", undefined, { timeout: "3s" });
+
+// @ts-expect-error
+fetch();
+fetch("http://foo.bar");
+fetch("http://foo.bar", {});
+fetch("http://foo.bar", { method: "POST" });
+// @ts-expect-error
+fetch("http://foo.bar", { method: 12 });
+fetch("http://foo.bar", { headers: { "Accept": "application/json" } });
+fetch("http://foo.bar", { body: { foo: "bar" } });
+fetch("http://foo.bar", { maxRedirects: 1 });
+fetch("http://foo.bar", { timeout: 3000 });
+fetch("http://foo.bar", { timeout: "3s" });