@rapidrest/service-core 1.0.0-beta.1

package/dist/types/routes/ModelRoute.d.ts

@@ -0,0 +1,226 @@
+import { RepoOperationOptions, RepoUtils } from "../models/RepoUtils.js";
+import { BaseEntity } from "../models/BaseEntity.js";
+import { Redis } from "ioredis";
+import type { HttpRequest as XRequest, HttpResponse as XResponse } from "../http/index.js";
+import { SimpleEntity } from "../models/SimpleEntity.js";
+import { AccessControlList } from "../security/AccessControlList.js";
+import { ACLUtils } from "../security/ACLUtils.js";
+import { NotificationUtils } from "../NotificationUtils.js";
+import { ObjectFactory } from "../ObjectFactory.js";
+/**
+ * The set of options required by all request handlers.
+ */
+export interface RequestOptions extends RepoOperationOptions {
+    /** The originating client request. */
+    req?: XRequest;
+    /** The outgoing client response. */
+    res?: XResponse;
+}
+/**
+ * The set of options required by create request handlers.
+ */
+export interface CreateRequestOptions extends RequestOptions {
+    acl?: AccessControlList | AccessControlList[];
+    /** An additional list of channel names to send push notifications to. */
+    pushChannels?: string[];
+    /** Set to `true` to not send a push notification. */
+    skipPush?: boolean;
+}
+/**
+ * The set of options required by delete request handlers.
+ */
+export interface DeleteRequestOptions extends RequestOptions {
+    /** The desired product uid of the resource to delete. */
+    productUid?: string;
+    /** Set to true to permanently remove the object from the database (if applicable). */
+    purge?: boolean;
+    /** An additional list of channel names to send push notifications to. */
+    pushChannels?: string[];
+    /** Set to `true` to not send a push notification. */
+    skipPush?: boolean;
+    /** The desired version number of the resource to delete. */
+    version?: number | string;
+}
+/**
+ * The set of options required by search request handlers.
+ */
+export interface FindRequestOptions extends RequestOptions {
+    /** The list of URL parameters to use in the search. */
+    params?: any;
+    /** The list of query parameters to use in the search. */
+    query: any;
+}
+/**
+ * The set of options required by truncate request handlers.
+ */
+export interface TruncateRequestOptions extends DeleteRequestOptions {
+    /** The list of URL parameters to use in the search. */
+    params: any;
+    /** An additional list of channel names to send push notifications to. */
+    pushChannels?: string[];
+    /** The list of query parameters to use in the search. */
+    query: any;
+    /** Set to `true` to not send a push notification. */
+    skipPush?: boolean;
+}
+/** A Partial type for a BaseEntity or SimpleEntity. */
+export type UpdateObject<T extends BaseEntity | SimpleEntity> = Partial<T> & Pick<T, "uid">;
+/**
+ * The set of options required by update request handlers.
+ */
+export interface UpdateRequestOptions<T extends BaseEntity | SimpleEntity> extends RequestOptions {
+    /** The existing object that has already been recently pulled from the datastore. */
+    existing?: T | null;
+    /** The desired product uid of the resource to update. */
+    productUid?: string;
+    /** An additional list of channel names to send push notifications to. */
+    pushChannels?: string[];
+    /** Set to `true` to not send a push notification. */
+    skipPush?: boolean;
+    /** The desired version number of the resource to update. */
+    version?: number | string;
+}
+/**
+ * The `ModelRoute` is an abstract base class that provides a set of built-in route behavior functions for handling
+ * requests for a given data model that is managed by a persistent datastore.
+ *
+ * Provided behaviors:
+ * * `count` - Counts the number of objects matching the provided set of criteria in the request's query parameters.
+ * * `create` - Adds a new object to the datastore.
+ * * `delete` - Removes an existing object from the datastore.
+ * * `find` - Finds all objects matching the provided set of criteria in the request's query parameters.
+ * * `findById` - Finds a single object with a specified unique identifier.
+ * * `truncate` - Removes all objects from the datastore.
+ * * `update` - Modifies an existing object in the datastore.
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export declare abstract class ModelRoute<T extends BaseEntity | SimpleEntity> {
+    protected aclUtils?: ACLUtils;
+    /** The redis client that will be used as a 2nd level cache for all cacheable models. */
+    protected cacheClient?: Redis;
+    /** The global application configuration. */
+    protected config?: any;
+    /** The unique identifier of the default ACL for the model type. */
+    protected defaultACLUid: string;
+    protected logger: any;
+    protected notificationUtils?: NotificationUtils;
+    protected objectFactory?: ObjectFactory;
+    /** The class of the RepoUtils to use when instantiating the utility. */
+    protected readonly abstract repoUtilsClass: any;
+    /** The repository utility class to use for common operations. */
+    protected repoUtils?: RepoUtils<T>;
+    /**
+     * The number of previous document versions to store in the database. A negative value indicates storing all
+     * versions, a value of `0` stores no versions.
+     */
+    protected trackChanges: number;
+    protected trustedRoles: string[];
+    /**
+     * The class type of the model this route is associated with.
+     */
+    protected get modelClass(): any;
+    /**
+     * Called on server startup to initialize the route with any defaults.
+     */
+    private superInitialize;
+    /**
+     * Attempts to retrieve the number of data model objects matching the given set of criteria as specified in the
+     * request `query`. Any results that have been found are set to the `content-length` header of the `res` argument.
+     *
+     * @param options The options to process the request using.
+     */
+    protected doCount(options: FindRequestOptions): Promise<XResponse>;
+    /**
+     * Attempts to store an object provided in `options.req.body` into the datastore. Upon success, sets the newly persisted
+     * object(s) to the `result` property of the `options.res` argument, otherwise sends a `400 BAD REQUEST` response to the
+     * client.
+     *
+     * @param obj The object to store in the database.
+     * @param options The options to process the request using.
+     */
+    protected doCreateObject(obj: Partial<T>, options: CreateRequestOptions): Promise<T>;
+    /**
+     * Attempts to store a collection of objects provided in `options.req.body` into the datastore. Upon success, sets the newly persisted
+     * object(s) to the `result` property of the `options.res` argument, otherwise sends a `400 BAD REQUEST` response to the
+     * client.
+     *
+     * @param objs The object(s) to store in the database.
+     * @param options The options to process the request using.
+     */
+    protected doBulkCreate(objs: Partial<T>[], options: CreateRequestOptions): Promise<T[]>;
+    /**
+     * Attempts to store one or more objects provided in `options.req.body` into the datastore. Upon success, sets the newly persisted
+     * object(s) to the `result` property of the `options.res` argument, otherwise sends a `400 BAD REQUEST` response to the
+     * client.
+     *
+     * @param obj The object(s) to store in the database.
+     * @param options The options to process the request using.
+     */
+    protected doCreate(obj: Partial<T> | Partial<T>[], options: CreateRequestOptions): Promise<T | T[]>;
+    /**
+     * Attempts to delete an existing data model object with a given unique identifier encoded by the URI parameter
+     * `id`.
+     *
+     * @param id The unique identifier of the object to delete.
+     * @param options The options to process the request using.
+     */
+    protected doDelete(id: string, options: DeleteRequestOptions): Promise<void>;
+    /**
+     * Attempts to determine if an existing object with the given unique identifier exists.
+     *
+     * @param id The unique identifier of the object to verify exists.
+     * @param options The options to process the request using.
+     */
+    protected doExists(id: string, options: FindRequestOptions): Promise<any>;
+    /**
+     * Attempts to retrieve all data model objects matching the given set of criteria as specified in the request
+     * `query`. Any results that have been found are set to the `result` property of the `res` argument. `result` is
+     * never null.
+     *
+     * @param options The options to process the request using.
+     */
+    protected doFindAll(options: FindRequestOptions): Promise<T[]>;
+    /**
+     * Attempts to retrieve a single data model object as identified by the `id` parameter in the URI.
+     *
+     * @param options The options to process the request using.
+     */
+    protected doFindById(id: string, options: FindRequestOptions): Promise<T | null>;
+    /**
+     * Attempts to remove all entries of the data model type from the datastore matching the given
+     * parameters and query.
+     *
+     * @param options The options to process the request using.
+     */
+    protected doTruncate(options: TruncateRequestOptions): Promise<void>;
+    /**
+     * Attempts to modify a collection of existing data model objects.
+     *
+     * @param objs The object(s) to bulk update in the database.
+     * @param options The options to process the request using.
+     */
+    protected doBulkUpdate(objs: UpdateObject<T>[], options: UpdateRequestOptions<T>): Promise<T[]>;
+    /**
+     * Attempts to modify an existing data model object as identified by the `id` parameter in the URI.
+     *
+     * @param obj The object to update in the database
+     * @param options The options to process the request using.
+     */
+    protected doUpdate(id: string, obj: UpdateObject<T>, options: UpdateRequestOptions<T>): Promise<T>;
+    /**
+     * Attempts to modify a single property of an existing data model object as identified by the `id` parameter in the URI.
+     *
+     * Note that this effectively bypasses optimistic locking and can cause unexpected data overwrites. Use with care.
+     *
+     * @param id The unique identifier of the object to update.
+     * @param propertyName The name of the property to update.
+     * @param value The value of the property to set.
+     * @param options The options to process the request using.
+     */
+    protected doUpdateProperty(id: string, propertyName: string, value: any, options: UpdateRequestOptions<T>): Promise<T>;
+    /**
+     * Calls `repoUtils.validate()` to validate the object(s) provided.
+     */
+    protected doValidate(objs: Partial<T> | Partial<T>[], options?: CreateRequestOptions | UpdateRequestOptions<T>): Promise<void>;
+}

package/dist/types/routes/OpenAPIRoute.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The `OpenAPIRoute` provides default routes to expose the service's OpenAPI specification.
+ *
+ * - `GET /` — Swagger UI HTML (loads swagger-ui-dist from CDN)
+ * - `GET /openapi.json` — raw OpenAPI specification as JSON
+ * - `GET /openapi.yaml` — raw OpenAPI specification as YAML
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class OpenAPIRoute {
+    /** The underlying OpenAPI specification. */
+    private apiSpec;
+    getHTML(): string;
+    getAPIDocs(): string;
+    getJSON(): any;
+    getYAML(): string;
+}

package/dist/types/routes/RouteUtils.d.ts

@@ -0,0 +1,55 @@
+import type { RequestHandler } from "../http/types.js";
+/**
+ * Provides a set of utilities for converting Route classes to HTTP middleware.
+ *
+ * @author Jean-Philippe Steinmetz <rapidrests@gmail.com>
+ */
+export declare class RouteUtils {
+    private aclUtils?;
+    private apiSpec;
+    private authMiddleware?;
+    private logger?;
+    /**
+     * Creates a middleware function that verifies the incoming request is from a valid user with at least
+     * one of the specified roles.
+     */
+    checkRequiredPerms(aclUid: string): RequestHandler;
+    /**
+     * Creates a middleware function that verifies the incoming request is from a valid user with at least
+     * one of the specified roles.
+     *
+     * @param requiredRoles The list of roles that the authenticated user must have.
+     */
+    checkRequiredRoles(requiredRoles: string[]): RequestHandler;
+    /**
+     * Converts the given array of string or Function objects to functions bound to the given route object.
+     *
+     * @param route The route object that the list of functions is bound to.
+     * @param funcs The array of functions (or function names) to return.
+     * @param send Set to true to have the last wrapped function send its payload to the client.
+     * @returns An array of Function objects mapping to the route object.
+     */
+    getFuncArray(route: any, funcs: (Function | string)[], send?: boolean): RequestHandler[];
+    /**
+     * Searches an route object for any functions that implement a `@Method` decorator.
+     *
+     * @param route The route object to search.
+     * @returns The list of `@Method` decorated functions that were found.
+     */
+    getRouteMethods(route: any): Map<string, any>;
+    /**
+     * Registers the provided route object containing a set of decorated endpoints to the server.
+     *
+     * @param app The HTTP application/router to register the route to.
+     * @param route The route object to register.
+     */
+    registerRoute(app: any, route: any): Promise<void>;
+    /**
+     * Wraps the provided function with HTTP handling based on the function's defined decorators.
+     *
+     * @param obj The bound object whose middleware function will be wrapped.
+     * @param func The decorated function to wrap.
+     * @param send Set to true to have `func`'s result sent to the client.
+     */
+    wrapMiddleware(obj: any, func: Function, send?: boolean): RequestHandler;
+}

package/dist/types/routes/StatusRoute.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The `StatusRoute` provides a default `/status` endpoint the returns metadata information about the service such as
+ * name, version.
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class StatusRoute {
+    private config;
+    private statusExtraData;
+    private get;
+}

package/dist/types/routes/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./AdminRoute.js";
+export * from "./MetricsRoute.js";
+export * from "./ModelRoute.js";
+export * from "./OpenAPIRoute.js";
+export * from "./RouteUtils.js";
+export * from "./StatusRoute.js";

package/dist/types/security/ACLRouteMongo.d.ts

@@ -0,0 +1,19 @@
+import { AccessControlListMongo } from "./AccessControlListMongo.js";
+import { MongoRepository as Repo } from "../database/MongoRepository.js";
+import { ModelRoute } from "../routes/ModelRoute.js";
+export declare class ACLRouteMongo extends ModelRoute<AccessControlListMongo> {
+    protected repo?: Repo<AccessControlListMongo>;
+    protected readonly repoUtilsClass: any;
+    constructor();
+    /**
+     * The base key used to get or set data in the cache.
+     */
+    protected get baseCacheKey(): string;
+    private create;
+    private updateBulk;
+    private count;
+    private findAll;
+    private delete;
+    private findById;
+    private update;
+}

package/dist/types/security/ACLRouteSQL.d.ts

@@ -0,0 +1,19 @@
+import { AccessControlListSQL } from "./AccessControlListSQL.js";
+import type { Repository as Repo } from "typeorm";
+import { ModelRoute } from "../routes/ModelRoute.js";
+export declare class ACLRouteSQL extends ModelRoute<AccessControlListSQL> {
+    protected repo?: Repo<AccessControlListSQL>;
+    protected readonly repoUtilsClass: any;
+    constructor();
+    /**
+     * The base key used to get or set data in the cache.
+     */
+    protected get baseCacheKey(): string;
+    private create;
+    private updateBulk;
+    private count;
+    private findAll;
+    private delete;
+    private findById;
+    private update;
+}

package/dist/types/security/ACLUtils.d.ts

@@ -0,0 +1,94 @@
+import { JWTUser } from "@rapidrest/core";
+import type { HttpRequest as Request } from "../http/index.js";
+import { AccessControlList, ACLAction, ACLRecord } from "./AccessControlList.js";
+/**
+ * Common utility functions for working with `AccessControlList` objects and validating user permissions.
+ */
+export declare class ACLUtils {
+    private cacheTTL;
+    private connMgr?;
+    private trustedRoles;
+    private get cacheClient();
+    private get repo();
+    /**
+     * Checks to see if the provided user matches the providedUserOrRoleId.
+     * @param user The user to check.
+     * @param userOrRoleId The ACL record id to check against.
+     * @returns `true` if the user contains a `uid` or `role` that matches the `userOrRoleId`, otherwise `false`.
+     */
+    private userMatchesId;
+    /**
+     * Validates that the user has permission to perform the request operation against the URL path for the
+     * provided request. If ACLUtils has not been initialized or the `acl` datastore has not been configured
+     * then always returns `true`.
+     *
+     * @param uid The uid of the access control list to verify against.
+     * @param user The user to validate.
+     * @param req The request whose URL path and method will be verified.
+     */
+    checkRequestPerms(uid: string, user: JWTUser | undefined, req: Request): Promise<boolean>;
+    /**
+     * Validates that the user has permission to perform the provided action using the given access control list.
+     *
+     * @param user The user to validate permissions of.
+     * @param acl The ACL or uid of an ACL to validate permissions against.
+     * @param action The action that the user desires permission for.
+     * @returns `true` if the user has at least one of the permissions granted for the given entity, otherwise `false`.
+     */
+    hasPermission(user: JWTUser | undefined, acl: AccessControlList | string, action: ACLAction): Promise<boolean>;
+    /**
+     * Retrieves the access control list with the associated identifier and populates the parent(s).
+     *
+     * @param entityId The unique identifier of the ACL to retrieve.
+     * @param parentUids The list of already found parent UIDs. This is used to break circular dependencies.
+     */
+    findACL(entityId: string, parentUids?: string[]): Promise<AccessControlList | null>;
+    /**
+     * Deletes the ACL with the given identifier from the database.
+     * @param uid The unique identifier of the ACL to remove.
+     */
+    removeACL(uid: string): Promise<void>;
+    /**
+     * Compares two ACLs to see if they have been modified and returns the total number of changes between them.
+     *
+     * @param aclA The source ACL to compare against.
+     * @param aclB The new ACL to compare with.
+     * @returns The total number of changes between the two ACLs.
+     */
+    private diffACL;
+    /**
+     * Stores the given access control list into the ACL database.
+     *
+     * @param acl The ACL to store.
+     * @return Returns the ACL that was stored in the database.
+     */
+    saveACL(acl: AccessControlList): Promise<AccessControlList | null>;
+    /**
+     * Stores the given default access control list into the ACL database. A default ACL is a special type of ACL
+     * that is primarily defined and maintained within the code but allows for user-specific overrides. To accomplish
+     * this, the provided ACL is split in two. A new record is automatically created with the `uid` of the form
+     * `default_<uid>` that stores the exact record as provided by code. Then a second ACL record is created
+     * with the `uid` being that of what is passed as the argument. This second ACL is used to store user-defined
+     * overrides. As the `default_<uid>` record is always overwritten with the lastest version of the code, any
+     * user-defined changes made to it are lost on service restart.
+     *
+     * @param defaultAcl
+     * @returns
+     */
+    saveDefaultACL(acl: AccessControlList): Promise<AccessControlList | null>;
+    /**
+     * Retrieves the first available record in the provided ACL associated with the provided user.
+     *
+     * @param acl The access control list that will be searched.
+     * @param user The user to find a record for.
+     * @returns The ACL record associated with the given user if found, otherwise `undefined`.
+     */
+    getRecord(acl: AccessControlList, user: JWTUser | undefined): ACLRecord | null;
+    /**
+     * Attempts to retrieve the parent access control list for the given ACL object.
+     *
+     * @param acl The access control list whose parents will be populated.
+     * @param parentUids The list of already found parent UIDs. This is used to break circular dependencies.
+     */
+    populateParent(acl: AccessControlList, parentUids?: string[]): Promise<void>;
+}

package/dist/types/security/AccessControlList.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Describes the various permission actions that can be performed against an entity.
+ *
+ * @author Jean-Philippe Steinmetz <rapidrests@gmail.com>
+ */
+export declare enum ACLAction {
+    CREATE = "CREATE",
+    DELETE = "DELETE",
+    FULL = "FULL",
+    READ = "READ",
+    SPECIAL = "SPECIAL",
+    UPDATE = "UPDATE"
+}
+/**
+ * The `ACLRecord` interface describes a single permissions entry in an `AccessControlList` that grants or denies
+ * a set of permissions to a single user or role.
+ *
+ * Each permission can be one of the following actions:
+ * - `Create` - The user or role can create a new record or object.
+ * - `Read` - The user or role can read the record or object.
+ * - `Update` - The user or role can modify existing records or objects.
+ * - `Delete` - The user or role can delete existing records or objects.
+ * - `Special` - The user or role has special prilieges to edit the ACL permissions.
+ * - `Full` - The user or role has total control over the record or object and supersedes any of the above.
+ *
+ * @author Jean-Philippe Steinmetz <rapidrests@gmail.com>
+ */
+export interface ACLRecord {
+    /**
+     * The unique identifier of the user or role that the record belongs to.
+     */
+    userOrRoleId: string;
+    /**
+     * Indicates that the user or role has permission to create new records of the entity.
+     */
+    create: boolean | null;
+    /**
+     * Indicates that the user or role has permission to read records of the entity.
+     */
+    read: boolean | null;
+    /**
+     * Indicates that the user or role has permission to modify existing records of the entity.
+     */
+    update: boolean | null;
+    /**
+     * Indicates that the user or role has permission to delete existing records of the entity.
+     */
+    delete: boolean | null;
+    /**
+     * Indicates that the user or role has special permission over records of the entity. The exact meaning of this
+     * may vary by service.
+     */
+    special: boolean | null;
+    /**
+     * Indicates that the user or role has total control over records of the entity. This supersedes all of the above
+     * permissions.
+     */
+    full: boolean | null;
+}
+/**
+ * The access control list provides a generic interface for the storage of user and roles permissions. Each ACL object
+ * represents the permission set for a single entity within the system. The entity is identified generically by its
+ * universally unique identifier (`uuid`). Each entry in the ACL records the permissions available to a particular user
+ * or role.
+ *
+ * Each permission can be one of the following actions:
+ * - `Create` - The user or role can create a new record or object.
+ * - `Read` - The user or role can read the record or object.
+ * - `Update` - The user or role can modify existing records or objects.
+ * - `Delete` - The user or role can delete existing records or objects.
+ * - `Special` - The user or role has special prilieges to edit the ACL permissions.
+ * - `Full` - The user or role has total control over the record or object and supersedes any of the above.
+ *
+ * For each of the above actions the user or role will be granted either an `allow` permission or a `deny` permission.
+ * If an `allow` is granted, the user or role has permission to perform that action. If a `deny` is set, then the user
+ * or role is denied that action. If no explicit `allow` or `deny` is set then the user or role will inherit the
+ * permission from a parent role or ACL.
+ *
+ * ACLs can be chained via single inheritance through the specification of the `parentUid`. This allows the ability to
+ * create complex trees of permissions that can easily inherit control schemes to make the definition of permissions
+ * easier.
+ *
+ * @author Jean-Philippe Steinmetz <rapidrests@gmail.com>
+ */
+export interface AccessControlList {
+    /**
+     * The universally unique identifier (`uuid`) of the entity that the access control list belongs to.
+     */
+    uid: string;
+    /**
+     * The parent access control list that this instance inherits permissions from.
+     */
+    parent?: AccessControlList | null;
+    /**
+     * The universally unique identifier of the parent `AccessControlList` that this object will inherit permissions
+     * from.
+     */
+    parentUid?: string;
+    /**
+     * The list of all permission records associated with this access control list.
+     */
+    records: ACLRecord[];
+}

package/dist/types/security/AccessControlListMongo.d.ts

@@ -0,0 +1,24 @@
+import { BaseMongoEntity } from "../models/index.js";
+import { AccessControlList, ACLRecord } from "./AccessControlList.js";
+/**
+ * Implementation of the `ACLRecord` interface for use with MongoDB databases.
+ */
+export declare class ACLRecordMongo implements ACLRecord {
+    userOrRoleId: string;
+    create: boolean | null;
+    read: boolean | null;
+    update: boolean | null;
+    delete: boolean | null;
+    special: boolean | null;
+    full: boolean | null;
+    constructor(other?: any);
+}
+/**
+ * Implementation of the `AccessControlList` interface for use with MongoDB databases.
+ */
+export declare class AccessControlListMongo extends BaseMongoEntity implements AccessControlList {
+    parent?: AccessControlList;
+    parentUid?: string | undefined;
+    records: ACLRecordMongo[];
+    constructor(other?: any);
+}

package/dist/types/security/AccessControlListSQL.d.ts

@@ -0,0 +1,24 @@
+import { BaseEntity } from "../models/BaseEntity.js";
+import { AccessControlList, ACLRecord } from "./AccessControlList.js";
+/**
+ * Implementation of the `ACLRecord` interface for use with SQL databases.
+ */
+export declare class ACLRecordSQL implements ACLRecord {
+    userOrRoleId: string;
+    create: boolean | null;
+    read: boolean | null;
+    update: boolean | null;
+    delete: boolean | null;
+    special: boolean | null;
+    full: boolean | null;
+    constructor(other?: any);
+}
+/**
+ * Implementation of the `AccessControlList` interface for use with SQL databases.
+ */
+export declare class AccessControlListSQL extends BaseEntity implements AccessControlList {
+    parent?: AccessControlList;
+    parentUid?: string | undefined;
+    records: ACLRecordSQL[];
+    constructor(other?: any);
+}

package/dist/types/security/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./AccessControlList.js";
+export * from "./ACLUtils.js";

package/dist/types/test/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./request.js";
+export * from "./requestws.js";

package/dist/types/test/request.d.ts

@@ -0,0 +1,24 @@
+/** Minimal supertest-compatible response shape. */
+export interface TestResponse {
+    status: number;
+    statusCode: number;
+    body: any;
+    text: string;
+    /** MIME type extracted from the content-type header (without charset). */
+    type: string;
+    headers: Record<string, string>;
+    ok: boolean;
+}
+/**
+ * Creates a supertest-style request builder that sends requests via axios to
+ * `http://localhost:<port>`.
+ */
+export declare function request(app: any): {
+    get: (url: string) => any;
+    post: (url: string) => any;
+    put: (url: string) => any;
+    delete: (url: string) => any;
+    patch: (url: string) => any;
+    head: (url: string) => any;
+    options: (url: string) => any;
+};

package/dist/types/test/requestws.d.ts

@@ -0,0 +1,21 @@
+/** Fluent WebSocket test chain, mirrors the superwstest API. */
+export declare class WsChain {
+    private readonly url;
+    private readonly wsOptions?;
+    private readonly actions;
+    constructor(url: string, wsOptions?: any);
+    expectText(value: string): this;
+    expectJson(value: any): this;
+    expectClosed(code?: number, reason?: string): this;
+    sendText(value: string): this;
+    sendJson(value: any): this;
+    close(): this;
+    /** Execute the queued actions and resolve when all pass. */
+    then<TResult1 = void, TResult2 = never>(onFulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<void | TResult>;
+    private _run;
+}
+/** Creates a superwstest-style chain connected to `ws://localhost:<port>`. */
+export declare function requestws(appOrPort: any): {
+    ws(path: string, options?: any): WsChain;
+};