@jaypie/testkit 1.1.25 → 1.1.27

package/dist/mock/core.d.ts

@@ -0,0 +1,306 @@
+import { log } from "@jaypie/core";
+import * as original from "@jaypie/core";
+export declare const BadGatewayError: typeof original.BadGatewayError;
+export declare const BadRequestError: typeof original.BadRequestError;
+export declare const ConfigurationError: typeof original.ConfigurationError;
+export declare const ForbiddenError: typeof original.ForbiddenError;
+export declare const GatewayTimeoutError: typeof original.GatewayTimeoutError;
+export declare const GoneError: typeof original.GoneError;
+export declare const IllogicalError: typeof original.IllogicalError;
+export declare const InternalError: typeof original.InternalError;
+export declare const MethodNotAllowedError: typeof original.MethodNotAllowedError;
+export declare const MultiError: typeof original.ProjectMultiError;
+export declare const NotFoundError: typeof original.NotFoundError;
+export declare const NotImplementedError: typeof original.NotImplementedError;
+export declare const ProjectError: typeof original.ProjectError;
+export declare const ProjectMultiError: typeof original.ProjectMultiError;
+export declare const RejectedError: typeof original.RejectedError;
+export declare const TeapotError: typeof original.TeapotError;
+export declare const UnauthorizedError: typeof original.UnauthorizedError;
+export declare const UnavailableError: typeof original.UnavailableError;
+export declare const UnhandledError: typeof original.UnhandledError;
+export declare const UnreachableCodeError: typeof original.UnreachableCodeError;
+export declare const validate: {
+    (argument: unknown, options?: original.ValidationOptions & {
+        type?: unknown;
+    }): boolean;
+    array<T = unknown>(argument: unknown, options?: original.ValidationOptions): argument is T[];
+    boolean(argument: unknown, options?: original.ValidationOptions): argument is boolean;
+    class(argument: unknown, options?: original.ValidationOptions): boolean;
+    function(argument: unknown, options?: original.ValidationOptions): argument is (...args: unknown[]) => unknown;
+    null(argument: unknown, options?: original.ValidationOptions): argument is null;
+    number(argument: unknown, options?: original.ValidationOptions): argument is number;
+    object<T extends Record<string, unknown> = Record<string, unknown>>(argument: unknown, options?: original.ValidationOptions): argument is T;
+    string(argument: unknown, options?: original.ValidationOptions): argument is string;
+    undefined(argument: unknown, options?: original.ValidationOptions): argument is undefined;
+    optional: {
+        array<T = unknown>(argument: unknown, options?: original.ValidationOptions): argument is T[] | undefined;
+        boolean(argument: unknown, options?: original.ValidationOptions): argument is boolean | undefined;
+        class(argument: unknown, options?: original.ValidationOptions): boolean;
+        function(argument: unknown, options?: original.ValidationOptions): argument is ((...args: unknown[]) => unknown) | undefined;
+        null(argument: unknown, options?: original.ValidationOptions): argument is null | undefined;
+        number(argument: unknown, options?: original.ValidationOptions): argument is number | undefined;
+        object<T extends Record<string, unknown> = Record<string, unknown>>(argument: unknown, options?: original.ValidationOptions): argument is T | undefined;
+        string(argument: unknown, options?: original.ValidationOptions): argument is string | undefined;
+    };
+};
+export { log };
+export declare const cloneDeep: (...args: unknown[]) => unknown;
+export declare const envBoolean: (...args: unknown[]) => boolean;
+export declare const envsKey: (...args: unknown[]) => unknown;
+export declare const errorFromStatusCode: ((statusCode: number, message?: string) => Error) & {
+    mock: any;
+};
+export declare const formatError: (...args: unknown[]) => unknown;
+export declare const getHeaderFrom: (...args: unknown[]) => unknown;
+export declare const getObjectKeyCaseInsensitive: (...args: unknown[]) => unknown;
+export declare const isClass: (...args: unknown[]) => unknown;
+export declare const isJaypieError: (...args: unknown[]) => unknown;
+export declare const optional: {
+    (value: unknown, type: unknown, options?: Record<string, unknown>): boolean;
+    array<T = unknown>(value: unknown): value is T[] | undefined;
+    boolean(value: unknown): value is boolean | undefined;
+    number(value: unknown): value is number | undefined;
+    object<T extends Record<string, unknown> = Record<string, unknown>>(value: unknown): value is T | undefined;
+    positive(value: unknown): value is number | undefined;
+    string(value: unknown, defaultValue?: string): value is string | undefined;
+};
+export declare const required: {
+    (value: unknown, type: unknown, options?: Record<string, unknown>): boolean;
+    array<T = unknown>(value: unknown): value is T[];
+    boolean(value: unknown): value is boolean;
+    number(value: unknown): value is number;
+    object<T extends Record<string, unknown> = Record<string, unknown>>(value: unknown): value is T;
+    positive(value: unknown): value is number;
+    string(value: unknown, defaultValue?: string): value is string;
+};
+export declare const safeParseFloat: (...args: unknown[]) => unknown;
+export declare const placeholders: (...args: unknown[]) => unknown;
+export declare const force: {
+    (value: unknown, type: unknown, options?: string | {
+        key?: string;
+        maximum?: number;
+        minimum?: number;
+        nan?: boolean;
+    }): unknown;
+    array<T = unknown>(value: unknown): T[];
+    boolean(value: unknown): boolean;
+    number(value: unknown): number;
+    object<T extends Record<string, unknown> = Record<string, unknown>>(value: unknown, key?: string): T;
+    positive(value: unknown): number;
+    string(value: unknown, defaultValue?: string): string;
+};
+export declare const jaypieHandler: ((handler: Function, options?: {
+    setup?: Function | Function[];
+    teardown?: Function | Function[];
+    unavailable?: boolean;
+    validate?: Function | Function[];
+}) => Function) & {
+    mock: any;
+};
+export declare const sleep: (...args: unknown[]) => Promise<boolean>;
+export declare const uuid: (...args: unknown[]) => unknown;
+export declare const ERROR: {
+    MESSAGE: {
+        BAD_GATEWAY: "An unexpected error occurred on an upstream resource";
+        BAD_REQUEST: "The request was not properly formatted";
+        CONFIGURATION_ERROR: "The application responding to the request encountered a configuration error";
+        FORBIDDEN: "Access to this resource is not authorized";
+        GATEWAY_TIMEOUT: "The connection timed out waiting for an upstream resource";
+        GONE: "The requested resource is no longer available";
+        ILLOGICAL: "The application encountered an illogical condition while processing the request";
+        INTERNAL_ERROR: "An unexpected error occurred and the request was unable to complete";
+        METHOD_NOT_ALLOWED: "The requested method is not allowed";
+        NOT_FOUND: "The requested resource was not found";
+        NOT_IMPLEMENTED: "The request was understood but the resource is not implemented";
+        REJECTED: "The request was rejected prior to processing";
+        TEAPOT: "This resource is a teapot incapable of processing the request";
+        UNAUTHORIZED: "The request did not include valid authentication credentials";
+        UNAVAILABLE: "The requested resource is temporarily unavailable";
+        UNHANDLED: "An unhandled error occurred and the request was unable to complete";
+        UNREACHABLE_CODE: "The application encountered an unreachable condition while processing the request";
+    };
+    TITLE: {
+        BAD_GATEWAY: "Bad Gateway";
+        BAD_REQUEST: "Bad Request";
+        CONFIGURATION_ERROR: "Internal Configuration Error";
+        FORBIDDEN: "Forbidden";
+        GATEWAY_TIMEOUT: "Gateway Timeout";
+        GONE: "Gone";
+        INTERNAL_ERROR: "Internal Application Error";
+        METHOD_NOT_ALLOWED: "Method Not Allowed";
+        NOT_FOUND: "Not Found";
+        NOT_IMPLEMENTED: "Not Implemented";
+        REJECTED: "Request Rejected";
+        TEAPOT: "Teapot";
+        UNAUTHORIZED: "Service Unauthorized";
+        UNAVAILABLE: "Service Unavailable";
+    };
+    TYPE: {
+        BAD_GATEWAY: "BAD_GATEWAY";
+        BAD_REQUEST: "BAD_REQUEST";
+        CONFIGURATION_ERROR: "CONFIGURATION_ERROR";
+        FORBIDDEN: "FORBIDDEN";
+        GATEWAY_TIMEOUT: "GATEWAY_TIMEOUT";
+        GONE: "GONE";
+        ILLOGICAL: "ILLOGICAL";
+        INTERNAL_ERROR: "INTERNAL_ERROR";
+        METHOD_NOT_ALLOWED: "METHOD_NOT_ALLOWED";
+        MULTI_ERROR: "MULTI_ERROR";
+        NOT_FOUND: "NOT_FOUND";
+        NOT_IMPLEMENTED: "NOT_IMPLEMENTED";
+        REJECTED: "REJECTED";
+        TEAPOT: "TEAPOT";
+        UNAUTHORIZED: "UNAUTHORIZED";
+        UNAVAILABLE: "UNAVAILABLE";
+        UNHANDLED: "UNHANDLED";
+        UNKNOWN_TYPE: "UNKNOWN_TYPE";
+        UNREACHABLE_CODE: "UNREACHABLE_CODE";
+    };
+};
+export declare const HTTP: {
+    ALLOW: {
+        ANY: "*";
+    };
+    CODE: {
+        OK: 200;
+        CREATED: 201;
+        ACCEPTED: 202;
+        NO_CONTENT: 204;
+        FOUND: 302;
+        BAD_REQUEST: 400;
+        UNAUTHORIZED: 401;
+        FORBIDDEN: 403;
+        NOT_FOUND: 404;
+        METHOD_NOT_ALLOWED: 405;
+        CONFLICT: 409;
+        GONE: 410;
+        TEAPOT: 418;
+        INTERNAL_ERROR: 500;
+        BAD_GATEWAY: 502;
+        UNAVAILABLE: 503;
+        GATEWAY_TIMEOUT: 504;
+    };
+    CONTENT: {
+        ANY: "*/*";
+        HTML: "text/html";
+        JSON: "application/json";
+        TEXT: "text/plain";
+    };
+    HEADER: {
+        ACCEPT: "Accept";
+        ACCEPT_ENCODING: "Accept-Encoding";
+        ALLOW: {
+            HEADERS: "Access-Control-Allow-Headers";
+            METHODS: "Access-Control-Allow-Methods";
+            ORIGIN: "Access-Control-Allow-Origin";
+        };
+        AMAZON: {
+            CF_ID: "X-Amz-Cf-Id";
+            CLOUDFRONT_COUNTRY: "CloudFront-Viewer-Country";
+            CLOUDFRONT_DESKTOP: "CloudFront-Is-Desktop-Viewer";
+            CLOUDFRONT_MOBILE: "CloudFront-Is-Mobile-Viewer";
+            CLOUDFRONT_PROTOCOL: "CloudFront-Forwarded-Proto";
+            CLOUDFRONT_SMARTTV: "CloudFront-Is-SmartTV-Viewer";
+            CLOUDFRONT_TABLET: "CloudFront-Is-Tablet-Viewer";
+            TRACE_ID: "X-Amzn-Trace-Id";
+        };
+        AUTHORIZATION: "Authorization";
+        CACHE_CONTROL: "Cache-Control";
+        CONTENT_TYPE: "Content-Type";
+        COOKIE: {
+            REQUEST: "Cookie";
+            RESPONSE: "Set-Cookie";
+        };
+        DATADOG: {
+            SESSION_ID: "X-Session-Id";
+        };
+        FORWARDED: {
+            FOR: "X-Forwarded-For";
+            PORT: "X-Forwarded-Port";
+            PROTOCOL: "X-Forwarded-Proto";
+        };
+        HOST: "Host";
+        ORIGIN: "Origin";
+        POSTMAN: {
+            TOKEN: "Postman-Token";
+        };
+        POWERED_BY: "X-Powered-By";
+        PROJECT: {
+            ACCOUNT: "X-Project-Account";
+            CALLER: "X-Project-Caller";
+            ENVIRONMENT: "X-Project-Environment";
+            KEY: "X-Project-Key";
+            HANDLER: "X-Project-Handler";
+            INVOCATION: "X-Project-Invocation";
+            ROOT_INVOCATION: "X-Project-Root-Invocation";
+            SECRET: "X-Project-Secret";
+            SEED: "X-Project-Seed";
+            SESSION: "X-Project-Session";
+            VERSION: "X-Project-Version";
+        };
+        SIGNATURE: {
+            ED25519: "X-Signature-Ed25519";
+            TIMESTAMP: "X-Signature-Timestamp";
+        };
+        USER_AGENT: "User-Agent";
+        VIA: "Via";
+    };
+    METHOD: {
+        DELETE: "DELETE";
+        HEAD: "HEAD";
+        GET: "GET";
+        OPTIONS: "OPTIONS";
+        POST: "POST";
+        PUT: "PUT";
+    };
+    RESPONSE: Record<string, unknown>;
+};
+export declare const JAYPIE: {
+    LIB: {
+        AWS: "@jaypie/aws";
+        CDK: "@jaypie/cdk";
+        CONSTRUCTS: "@jaypie/constructs";
+        CORE: "@jaypie/core";
+        ESLINT: "@jaypie/eslint";
+        EXPRESS: "@jaypie/express";
+        ERRORS: "@jaypie/errors";
+        JAYPIE: "jaypie";
+        LAMBDA: "@jaypie/lambda";
+        LLM: "@jaypie/llm";
+        MONGOOSE: "@jaypie/mongoose";
+        TESTKIT: "@jaypie/testkit";
+        WEBKIT: "@jaypie/webkit";
+    };
+    LAYER: {
+        EXPRESS: "express";
+        HANDLER: "handler";
+        JAYPIE: "jaypie";
+        LAMBDA: "lambda";
+        MODULE: "module";
+    };
+    LOGGER: {
+        DEFAULT: "default";
+        MODULE: "module";
+    };
+    UNKNOWN: "unknown";
+};
+export declare const PROJECT: {
+    SPONSOR: {
+        FINLAYSON: "finlaysonstudio";
+        JAYPIE: "jaypie";
+        KNOWDEV: "knowdev.studio";
+    };
+};
+export declare const VALIDATE: {
+    ANY: "*";
+    ARRAY: ArrayConstructor;
+    BOOLEAN: BooleanConstructor;
+    CLASS: "_CLASS";
+    FUNCTION: FunctionConstructor;
+    NUMBER: NumberConstructor;
+    NULL: null;
+    OBJECT: ObjectConstructor;
+    STRING: StringConstructor;
+    UNDEFINED: "_UNDEFINED";
+};

package/dist/mock/datadog.d.ts

@@ -0,0 +1,4 @@
+import * as original from "@jaypie/datadog";
+export declare const DATADOG: original.DatadogConstants;
+export declare const submitMetric: (...args: unknown[]) => Promise<boolean>;
+export declare const submitMetricSet: (...args: unknown[]) => Promise<boolean>;

package/dist/mock/express.d.ts

@@ -0,0 +1,32 @@
+export declare const EXPRESS: {
+    PATH: {
+        ANY: "*";
+        ID: "/:id";
+        ROOT: RegExp;
+    };
+};
+export declare const badRequestRoute: (...args: unknown[]) => unknown;
+export declare const echoRoute: (...args: unknown[]) => unknown;
+export declare const forbiddenRoute: (...args: unknown[]) => unknown;
+export declare const goneRoute: (...args: unknown[]) => unknown;
+export declare const methodNotAllowedRoute: (...args: unknown[]) => unknown;
+export declare const noContentRoute: (...args: unknown[]) => unknown;
+export declare const notFoundRoute: (...args: unknown[]) => unknown;
+export declare const notImplementedRoute: (...args: unknown[]) => unknown;
+export declare const expressHttpCodeHandler: (...args: unknown[]) => unknown;
+export declare const cors: (...args: unknown[]) => unknown;
+export interface ExpressHandlerFunction {
+    (req: any, res: any, ...extra: any[]): Promise<any> | any;
+}
+export interface ExpressHandlerOptions {
+    locals?: Record<string, any>;
+    setup?: any[] | Function;
+    teardown?: any[] | Function;
+    unavailable?: boolean;
+    validate?: any[] | Function;
+}
+type ExpressHandlerParameter = ExpressHandlerFunction | ExpressHandlerOptions;
+export declare const expressHandler: ((handlerOrProps: ExpressHandlerParameter, propsOrHandler?: ExpressHandlerParameter) => (req: any, res: any, ...extra: any[]) => Promise<any>) & {
+    mock: any;
+};
+export {};