@webpieces/core-util 0.3.263 → 0.3.265

package/src/http/errors.d.ts

@@ -0,0 +1,118 @@
+/**
+ * HTTP Error classes for webpieces-ts.
+ * These errors are used throughout the framework for consistent error handling.
+ */
+/**
+ * ProtocolError - Data class for error response body.
+ * This is what gets serialized and sent to the client.
+ */
+export declare class ProtocolError {
+    message?: string;
+    subType?: string;
+    field?: string;
+    waitSeconds?: number;
+    name?: string;
+    guiAlertMessage?: string;
+    errorCode?: string;
+}
+/**
+ * HttpError - Base error class with HTTP status code.
+ * All specific HTTP errors extend this class.
+ */
+export declare class HttpError extends Error {
+    code: number;
+    subType?: string;
+    readonly httpCause?: Error;
+    constructor(message: string, code: number, subType?: string, cause?: Error);
+}
+export declare const ENTITY_NOT_FOUND = "EntityNotFoundError";
+export declare const WRONG_LOGIN_TYPE = "wrongLoginType";
+export declare const WRONG_LOGIN = "wronglogin";
+export declare const NOT_APPROVED = "notapproved";
+export declare const EMAIL_NOT_CONFIRMED = "email_not_confirmed";
+export declare const WRONG_DOMAIN = "wrongdomain";
+export declare const WRONG_COMPANY = "wrongcompany";
+export declare const NO_REG_CODE = "noregcode";
+/**
+ * HttpNotFoundError - 404 Not Found.
+ */
+export declare class HttpNotFoundError extends HttpError {
+    constructor(message: string, cause?: Error);
+}
+/**
+ * EndpointNotFoundError - 404 for missing endpoints.
+ */
+export declare class EndpointNotFoundError extends HttpNotFoundError {
+    constructor(message: string, cause?: Error);
+}
+/**
+ * HttpBadRequestError - 400 Bad Request.
+ * Used for validation errors with optional field and GUI message.
+ */
+export declare class HttpBadRequestError extends HttpError {
+    field?: string;
+    guiMessage?: string;
+    constructor(message: string, field?: string, guiMessage?: string, cause?: Error);
+}
+/**
+ * HttpUnauthorizedError - 401 Unauthorized.
+ */
+export declare class HttpUnauthorizedError extends HttpError {
+    constructor(message: string, subType?: string, cause?: Error);
+}
+/**
+ * HttpForbiddenError - 403 Forbidden.
+ */
+export declare class HttpForbiddenError extends HttpError {
+    constructor(message: string, cause?: Error);
+}
+/**
+ * HttpTimeoutError - 408 Request Timeout.
+ */
+export declare class HttpTimeoutError extends HttpError {
+    constructor(message: string, cause?: Error);
+}
+/**
+ * HttpBadGatewayError - 502 Bad Gateway.
+ */
+export declare class HttpBadGatewayError extends HttpError {
+    constructor(message: string, cause?: Error);
+}
+/**
+ * HttpGatewayTimeoutError - 504 Gateway Timeout.
+ * SHOULD NOT BE USED SERVER SIDE SINCE ALBs will return 504 and it will not be translated
+ * to json body 'ProtocolError'.
+ */
+export declare class HttpGatewayTimeoutError extends HttpError {
+    constructor(message: string, cause?: Error);
+}
+/**
+ * HttpInternalServerError - 500 Internal Server Error.
+ */
+export declare class HttpInternalServerError extends HttpError {
+    constructor(message: string, cause?: Error);
+}
+/**
+ * HttpVendorError - 598 Vendor Error.
+ * Custom status code for vendor/external service errors with retry hint.
+ */
+export declare class HttpVendorError extends HttpError {
+    waitSeconds: number;
+    constructor(message: string, waitSeconds?: number, cause?: Error);
+}
+/**
+ * HttpUserError - User validation error with 2xx status code.
+ *
+ * Uses HTTP 266 (non-standard 2xx code) intentionally because:
+ * 1. User validation errors are "successful" from server perspective - user just made a mistake
+ * 2. Browser DevTools show 4xx/5xx codes in RED, which is confusing for user validation
+ * 3. Allows error to propagate up the stack via throw without triggering error monitoring
+ * 4. Avoids polluting logs with "errors" that are actually expected user behavior
+ *
+ * This is a deliberate design pattern - do NOT change to 4xx codes.
+ * Examples: "Email already exists", "Invalid password format", "Required field missing"
+ */
+export declare class HttpUserError extends HttpError {
+    errorCode?: string;
+    constructor(message: string, errorCode?: string, cause?: Error);
+}

package/src/http/errors.js

@@ -0,0 +1,189 @@
+"use strict";
+/**
+ * HTTP Error classes for webpieces-ts.
+ * These errors are used throughout the framework for consistent error handling.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpUserError = exports.HttpVendorError = exports.HttpInternalServerError = exports.HttpGatewayTimeoutError = exports.HttpBadGatewayError = exports.HttpTimeoutError = exports.HttpForbiddenError = exports.HttpUnauthorizedError = exports.HttpBadRequestError = exports.EndpointNotFoundError = exports.HttpNotFoundError = exports.NO_REG_CODE = exports.WRONG_COMPANY = exports.WRONG_DOMAIN = exports.EMAIL_NOT_CONFIRMED = exports.NOT_APPROVED = exports.WRONG_LOGIN = exports.WRONG_LOGIN_TYPE = exports.ENTITY_NOT_FOUND = exports.HttpError = exports.ProtocolError = void 0;
+/**
+ * ProtocolError - Data class for error response body.
+ * This is what gets serialized and sent to the client.
+ */
+class ProtocolError {
+    message;
+    subType;
+    field;
+    waitSeconds;
+    name;
+    guiAlertMessage;
+    errorCode;
+}
+exports.ProtocolError = ProtocolError;
+/**
+ * HttpError - Base error class with HTTP status code.
+ * All specific HTTP errors extend this class.
+ */
+class HttpError extends Error {
+    code;
+    subType;
+    httpCause;
+    constructor(message, code, subType, cause) {
+        super(message);
+        this.code = code;
+        this.subType = subType;
+        this.httpCause = cause;
+    }
+}
+exports.HttpError = HttpError;
+// Error subtype constants
+exports.ENTITY_NOT_FOUND = 'EntityNotFoundError';
+exports.WRONG_LOGIN_TYPE = 'wrongLoginType';
+exports.WRONG_LOGIN = 'wronglogin';
+exports.NOT_APPROVED = 'notapproved';
+exports.EMAIL_NOT_CONFIRMED = 'email_not_confirmed';
+exports.WRONG_DOMAIN = 'wrongdomain';
+exports.WRONG_COMPANY = 'wrongcompany';
+exports.NO_REG_CODE = 'noregcode';
+/**
+ * HttpNotFoundError - 404 Not Found.
+ */
+class HttpNotFoundError extends HttpError {
+    constructor(message, cause) {
+        super(message, 404, undefined, cause);
+        this.name = exports.ENTITY_NOT_FOUND;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.HttpNotFoundError = HttpNotFoundError;
+/**
+ * EndpointNotFoundError - 404 for missing endpoints.
+ */
+class EndpointNotFoundError extends HttpNotFoundError {
+    constructor(message, cause) {
+        super(message, cause);
+        this.name = 'EndpointNotFoundError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.EndpointNotFoundError = EndpointNotFoundError;
+/**
+ * HttpBadRequestError - 400 Bad Request.
+ * Used for validation errors with optional field and GUI message.
+ */
+class HttpBadRequestError extends HttpError {
+    field;
+    guiMessage;
+    constructor(message, field, guiMessage, cause) {
+        super(message, 400, undefined, cause);
+        this.name = 'BadRequest';
+        this.field = field;
+        this.guiMessage = guiMessage;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.HttpBadRequestError = HttpBadRequestError;
+/**
+ * HttpUnauthorizedError - 401 Unauthorized.
+ */
+class HttpUnauthorizedError extends HttpError {
+    constructor(message, subType, cause) {
+        super(message, 401, subType, cause);
+        this.name = 'Unauthorized';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.HttpUnauthorizedError = HttpUnauthorizedError;
+/**
+ * HttpForbiddenError - 403 Forbidden.
+ */
+class HttpForbiddenError extends HttpError {
+    constructor(message, cause) {
+        super(message, 403, undefined, cause);
+        this.name = 'Forbidden';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.HttpForbiddenError = HttpForbiddenError;
+/**
+ * HttpTimeoutError - 408 Request Timeout.
+ */
+class HttpTimeoutError extends HttpError {
+    constructor(message, cause) {
+        super(message, 408, undefined, cause);
+        this.name = 'Timeout';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.HttpTimeoutError = HttpTimeoutError;
+/**
+ * HttpBadGatewayError - 502 Bad Gateway.
+ */
+class HttpBadGatewayError extends HttpError {
+    constructor(message, cause) {
+        super(message, 502, undefined, cause);
+        this.name = 'HttpBadGatewayError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.HttpBadGatewayError = HttpBadGatewayError;
+/**
+ * HttpGatewayTimeoutError - 504 Gateway Timeout.
+ * SHOULD NOT BE USED SERVER SIDE SINCE ALBs will return 504 and it will not be translated
+ * to json body 'ProtocolError'.
+ */
+class HttpGatewayTimeoutError extends HttpError {
+    constructor(message, cause) {
+        super(message, 504, undefined, cause);
+        this.name = 'HttpGatewayTimeoutError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.HttpGatewayTimeoutError = HttpGatewayTimeoutError;
+/**
+ * HttpInternalServerError - 500 Internal Server Error.
+ */
+class HttpInternalServerError extends HttpError {
+    constructor(message, cause) {
+        super(message, 500, undefined, cause);
+        this.name = 'InternalServerError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.HttpInternalServerError = HttpInternalServerError;
+/**
+ * HttpVendorError - 598 Vendor Error.
+ * Custom status code for vendor/external service errors with retry hint.
+ */
+class HttpVendorError extends HttpError {
+    waitSeconds;
+    constructor(message, waitSeconds = 30, cause) {
+        super(message, 598, undefined, cause);
+        this.waitSeconds = waitSeconds;
+        this.name = 'VendorError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.HttpVendorError = HttpVendorError;
+/**
+ * HttpUserError - User validation error with 2xx status code.
+ *
+ * Uses HTTP 266 (non-standard 2xx code) intentionally because:
+ * 1. User validation errors are "successful" from server perspective - user just made a mistake
+ * 2. Browser DevTools show 4xx/5xx codes in RED, which is confusing for user validation
+ * 3. Allows error to propagate up the stack via throw without triggering error monitoring
+ * 4. Avoids polluting logs with "errors" that are actually expected user behavior
+ *
+ * This is a deliberate design pattern - do NOT change to 4xx codes.
+ * Examples: "Email already exists", "Invalid password format", "Required field missing"
+ */
+class HttpUserError extends HttpError {
+    errorCode;
+    constructor(message, errorCode, cause) {
+        super(message, 266, 'USER_ERROR', cause);
+        this.name = 'UserError';
+        this.errorCode = errorCode;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.HttpUserError = HttpUserError;
+//# sourceMappingURL=errors.js.map

package/src/http/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../../../../../packages/core/core-util/src/http/errors.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * HTTP Error classes for webpieces-ts.\n * These errors are used throughout the framework for consistent error handling.\n */\n\n/**\n * ProtocolError - Data class for error response body.\n * This is what gets serialized and sent to the client.\n */\nexport class ProtocolError {\n    public message?: string;\n    public subType?: string;\n    public field?: string;\n    public waitSeconds?: number;\n    public name?: string;\n    public guiAlertMessage?: string;\n    public errorCode?: string;\n}\n\n/**\n * HttpError - Base error class with HTTP status code.\n * All specific HTTP errors extend this class.\n */\nexport class HttpError extends Error {\n    public code: number;\n    public subType?: string;\n    public readonly httpCause?: Error;\n\n    constructor(\n        message: string,\n        code: number,\n        subType?: string,\n        cause?: Error,\n    ) {\n        super(message);\n        this.code = code;\n        this.subType = subType;\n        this.httpCause = cause;\n    }\n}\n\n// Error subtype constants\nexport const ENTITY_NOT_FOUND = 'EntityNotFoundError';\nexport const WRONG_LOGIN_TYPE = 'wrongLoginType';\nexport const WRONG_LOGIN = 'wronglogin';\nexport const NOT_APPROVED = 'notapproved';\nexport const EMAIL_NOT_CONFIRMED = 'email_not_confirmed';\nexport const WRONG_DOMAIN = 'wrongdomain';\nexport const WRONG_COMPANY = 'wrongcompany';\nexport const NO_REG_CODE = 'noregcode';\n\n/**\n * HttpNotFoundError - 404 Not Found.\n */\nexport class HttpNotFoundError extends HttpError {\n    constructor(message: string, cause?: Error) {\n        super(message, 404, undefined, cause);\n        this.name = ENTITY_NOT_FOUND;\n        Object.setPrototypeOf(this, new.target.prototype);\n    }\n}\n\n/**\n * EndpointNotFoundError - 404 for missing endpoints.\n */\nexport class EndpointNotFoundError extends HttpNotFoundError {\n    constructor(message: string, cause?: Error) {\n        super(message, cause);\n        this.name = 'EndpointNotFoundError';\n        Object.setPrototypeOf(this, new.target.prototype);\n    }\n}\n\n/**\n * HttpBadRequestError - 400 Bad Request.\n * Used for validation errors with optional field and GUI message.\n */\nexport class HttpBadRequestError extends HttpError {\n    public field?: string;\n    public guiMessage?: string;\n\n    constructor(message: string, field?: string, guiMessage?: string, cause?: Error) {\n        super(message, 400, undefined, cause);\n        this.name = 'BadRequest';\n        this.field = field;\n        this.guiMessage = guiMessage;\n        Object.setPrototypeOf(this, new.target.prototype);\n    }\n}\n\n/**\n * HttpUnauthorizedError - 401 Unauthorized.\n */\nexport class HttpUnauthorizedError extends HttpError {\n    constructor(message: string, subType?: string, cause?: Error) {\n        super(message, 401, subType, cause);\n        this.name = 'Unauthorized';\n        Object.setPrototypeOf(this, new.target.prototype);\n    }\n}\n\n/**\n * HttpForbiddenError - 403 Forbidden.\n */\nexport class HttpForbiddenError extends HttpError {\n    constructor(message: string, cause?: Error) {\n        super(message, 403, undefined, cause);\n        this.name = 'Forbidden';\n        Object.setPrototypeOf(this, new.target.prototype);\n    }\n}\n\n/**\n * HttpTimeoutError - 408 Request Timeout.\n */\nexport class HttpTimeoutError extends HttpError {\n    constructor(message: string, cause?: Error) {\n        super(message, 408, undefined, cause);\n        this.name = 'Timeout';\n        Object.setPrototypeOf(this, new.target.prototype);\n    }\n}\n\n/**\n * HttpBadGatewayError - 502 Bad Gateway.\n */\nexport class HttpBadGatewayError extends HttpError {\n    constructor(message: string, cause?: Error) {\n        super(message, 502, undefined, cause);\n        this.name = 'HttpBadGatewayError';\n        Object.setPrototypeOf(this, new.target.prototype);\n    }\n}\n\n/**\n * HttpGatewayTimeoutError - 504 Gateway Timeout.\n * SHOULD NOT BE USED SERVER SIDE SINCE ALBs will return 504 and it will not be translated\n * to json body 'ProtocolError'.\n */\nexport class HttpGatewayTimeoutError extends HttpError {\n    constructor(message: string, cause?: Error) {\n        super(message, 504, undefined, cause);\n        this.name = 'HttpGatewayTimeoutError';\n        Object.setPrototypeOf(this, new.target.prototype);\n    }\n}\n\n/**\n * HttpInternalServerError - 500 Internal Server Error.\n */\nexport class HttpInternalServerError extends HttpError {\n    constructor(message: string, cause?: Error) {\n        super(message, 500, undefined, cause);\n        this.name = 'InternalServerError';\n        Object.setPrototypeOf(this, new.target.prototype);\n    }\n}\n\n/**\n * HttpVendorError - 598 Vendor Error.\n * Custom status code for vendor/external service errors with retry hint.\n */\nexport class HttpVendorError extends HttpError {\n    constructor(\n        message: string,\n        public waitSeconds = 30,\n        cause?: Error,\n    ) {\n        super(message, 598, undefined, cause);\n        this.name = 'VendorError';\n        Object.setPrototypeOf(this, new.target.prototype);\n    }\n}\n\n/**\n * HttpUserError - User validation error with 2xx status code.\n *\n * Uses HTTP 266 (non-standard 2xx code) intentionally because:\n * 1. User validation errors are \"successful\" from server perspective - user just made a mistake\n * 2. Browser DevTools show 4xx/5xx codes in RED, which is confusing for user validation\n * 3. Allows error to propagate up the stack via throw without triggering error monitoring\n * 4. Avoids polluting logs with \"errors\" that are actually expected user behavior\n *\n * This is a deliberate design pattern - do NOT change to 4xx codes.\n * Examples: \"Email already exists\", \"Invalid password format\", \"Required field missing\"\n */\nexport class HttpUserError extends HttpError {\n    public errorCode?: string;\n\n    constructor(message: string, errorCode?: string, cause?: Error) {\n        super(message, 266, 'USER_ERROR', cause);\n        this.name = 'UserError';\n        this.errorCode = errorCode;\n        Object.setPrototypeOf(this, new.target.prototype);\n    }\n}\n"]}

package/src/http/recorder/DoNotRecord.d.ts

@@ -0,0 +1,22 @@
+import 'reflect-metadata';
+/**
+ * @DoNotRecord - Property decorator marking a DTO field that must be omitted
+ * from recorded fixtures (port of Java @DoNotRecord).
+ *
+ * Use for volatile or sensitive fields (timestamps, generated ids, secrets)
+ * that would make recorded assertions flaky or leak data:
+ *
+ * ```typescript
+ * export class FetchValueResponse {
+ *     value?: string;
+ *     @DoNotRecord()
+ *     timestamp?: number;   // omitted from fixtures + generated assertions
+ * }
+ * ```
+ */
+export declare function DoNotRecord(): PropertyDecorator;
+/**
+ * Field names marked @DoNotRecord on the instance's class (empty for plain
+ * objects / interface-typed DTOs, which cannot carry decorators).
+ */
+export declare function getDoNotRecordFields(instance: object): string[];

package/src/http/recorder/DoNotRecord.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DoNotRecord = DoNotRecord;
+exports.getDoNotRecordFields = getDoNotRecordFields;
+require("reflect-metadata");
+const DO_NOT_RECORD_KEY = 'webpieces:do-not-record';
+/**
+ * @DoNotRecord - Property decorator marking a DTO field that must be omitted
+ * from recorded fixtures (port of Java @DoNotRecord).
+ *
+ * Use for volatile or sensitive fields (timestamps, generated ids, secrets)
+ * that would make recorded assertions flaky or leak data:
+ *
+ * ```typescript
+ * export class FetchValueResponse {
+ *     value?: string;
+ *     @DoNotRecord()
+ *     timestamp?: number;   // omitted from fixtures + generated assertions
+ * }
+ * ```
+ */
+function DoNotRecord() {
+    return (target, propertyKey) => {
+        const existing = Reflect.getMetadata(DO_NOT_RECORD_KEY, target.constructor) || [];
+        existing.push(String(propertyKey));
+        Reflect.defineMetadata(DO_NOT_RECORD_KEY, existing, target.constructor);
+    };
+}
+/**
+ * Field names marked @DoNotRecord on the instance's class (empty for plain
+ * objects / interface-typed DTOs, which cannot carry decorators).
+ */
+function getDoNotRecordFields(instance) {
+    if (!instance || typeof instance !== 'object') {
+        return [];
+    }
+    return Reflect.getMetadata(DO_NOT_RECORD_KEY, instance.constructor) || [];
+}
+//# sourceMappingURL=DoNotRecord.js.map

package/src/http/recorder/DoNotRecord.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DoNotRecord.js","sourceRoot":"","sources":["../../../../../../../packages/core/core-util/src/http/recorder/DoNotRecord.ts"],"names":[],"mappings":";;AAmBA,kCAMC;AAMD,oDAKC;AApCD,4BAA0B;AAE1B,MAAM,iBAAiB,GAAG,yBAAyB,CAAC;AAEpD;;;;;;;;;;;;;;GAcG;AACH,SAAgB,WAAW;IACvB,OAAO,CAAC,MAAc,EAAE,WAA4B,EAAQ,EAAE;QAC1D,MAAM,QAAQ,GAAa,OAAO,CAAC,WAAW,CAAC,iBAAiB,EAAE,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC;QAC5F,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC;QACnC,OAAO,CAAC,cAAc,CAAC,iBAAiB,EAAE,QAAQ,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC;IAC5E,CAAC,CAAC;AACN,CAAC;AAED;;;GAGG;AACH,SAAgB,oBAAoB,CAAC,QAAgB;IACjD,IAAI,CAAC,QAAQ,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE,CAAC;QAC5C,OAAO,EAAE,CAAC;IACd,CAAC;IACD,OAAO,OAAO,CAAC,WAAW,CAAC,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC;AAC9E,CAAC","sourcesContent":["import 'reflect-metadata';\n\nconst DO_NOT_RECORD_KEY = 'webpieces:do-not-record';\n\n/**\n * @DoNotRecord - Property decorator marking a DTO field that must be omitted\n * from recorded fixtures (port of Java @DoNotRecord).\n *\n * Use for volatile or sensitive fields (timestamps, generated ids, secrets)\n * that would make recorded assertions flaky or leak data:\n *\n * ```typescript\n * export class FetchValueResponse {\n *     value?: string;\n *     @DoNotRecord()\n *     timestamp?: number;   // omitted from fixtures + generated assertions\n * }\n * ```\n */\nexport function DoNotRecord(): PropertyDecorator {\n    return (target: object, propertyKey: string | symbol): void => {\n        const existing: string[] = Reflect.getMetadata(DO_NOT_RECORD_KEY, target.constructor) || [];\n        existing.push(String(propertyKey));\n        Reflect.defineMetadata(DO_NOT_RECORD_KEY, existing, target.constructor);\n    };\n}\n\n/**\n * Field names marked @DoNotRecord on the instance's class (empty for plain\n * objects / interface-typed DTOs, which cannot carry decorators).\n */\nexport function getDoNotRecordFields(instance: object): string[] {\n    if (!instance || typeof instance !== 'object') {\n        return [];\n    }\n    return Reflect.getMetadata(DO_NOT_RECORD_KEY, instance.constructor) || [];\n}\n"]}

package/src/http/recorder/RecordSerializer.d.ts

@@ -0,0 +1,39 @@
+/**
+ * RecordSerializer - JSON (de)serialization for recorded fixtures.
+ *
+ * Handles the cases plain JSON.stringify gets wrong for test fixtures:
+ * - Map values -> { __type: 'Map', entries: [...] } (revived back to Map)
+ * - Error values -> { __type: 'Error', name, message }
+ * - Fields marked @DoNotRecord on class DTOs are omitted
+ * - Dates serialize to ISO strings naturally (Date.prototype.toJSON)
+ *
+ * Fixtures stay diffable, human-editable JSON - the stable artifact that a
+ * generated spec (or an AI writing a spec) consumes.
+ */
+export declare class RecordSerializer {
+    /**
+     * Serialize a recorded value/test case to pretty-printed JSON.
+     */
+    serialize(value: unknown): string;
+    /**
+     * Parse fixture JSON back, reviving Map markers.
+     */
+    deserialize<T>(json: string): T;
+}
+/**
+ * Wire format for Map values inside fixtures.
+ */
+export declare class SerializedMap {
+    readonly entries: [unknown, unknown][];
+    readonly __type = "Map";
+    constructor(entries: [unknown, unknown][]);
+}
+/**
+ * Wire format for Error values inside fixtures.
+ */
+export declare class SerializedError {
+    readonly name: string;
+    readonly message: string;
+    readonly __type = "Error";
+    constructor(name: string, message: string);
+}

package/src/http/recorder/RecordSerializer.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializedError = exports.SerializedMap = exports.RecordSerializer = void 0;
+const DoNotRecord_1 = require("./DoNotRecord");
+/**
+ * RecordSerializer - JSON (de)serialization for recorded fixtures.
+ *
+ * Handles the cases plain JSON.stringify gets wrong for test fixtures:
+ * - Map values -> { __type: 'Map', entries: [...] } (revived back to Map)
+ * - Error values -> { __type: 'Error', name, message }
+ * - Fields marked @DoNotRecord on class DTOs are omitted
+ * - Dates serialize to ISO strings naturally (Date.prototype.toJSON)
+ *
+ * Fixtures stay diffable, human-editable JSON - the stable artifact that a
+ * generated spec (or an AI writing a spec) consumes.
+ */
+class RecordSerializer {
+    /**
+     * Serialize a recorded value/test case to pretty-printed JSON.
+     */
+    // webpieces-disable no-any-unknown -- serializer accepts arbitrary recorded DTOs
+    serialize(value) {
+        // webpieces-disable no-any-unknown -- JSON replacer is inherently untyped
+        return JSON.stringify(value, function (key, val) {
+            // `this` is the object containing `key` - consult @DoNotRecord on it
+            if (key !== '' && this && typeof this === 'object' && !Array.isArray(this)) {
+                const skipped = (0, DoNotRecord_1.getDoNotRecordFields)(this);
+                if (skipped.includes(key)) {
+                    return undefined;
+                }
+            }
+            if (val instanceof Map) {
+                return new SerializedMap(Array.from(val.entries()));
+            }
+            if (val instanceof Error) {
+                return new SerializedError(val.name, val.message);
+            }
+            return val;
+        }, 2);
+    }
+    /**
+     * Parse fixture JSON back, reviving Map markers.
+     */
+    deserialize(json) {
+        // webpieces-disable no-any-unknown -- JSON reviver is inherently untyped
+        return JSON.parse(json, (key, val) => {
+            if (val && typeof val === 'object' && val.__type === 'Map') {
+                return new Map(val.entries);
+            }
+            return val;
+        });
+    }
+}
+exports.RecordSerializer = RecordSerializer;
+/**
+ * Wire format for Map values inside fixtures.
+ */
+class SerializedMap {
+    entries;
+    __type = 'Map';
+    // webpieces-disable no-any-unknown -- Map entries carry arbitrary recorded values
+    constructor(entries) {
+        this.entries = entries;
+    }
+}
+exports.SerializedMap = SerializedMap;
+/**
+ * Wire format for Error values inside fixtures.
+ */
+class SerializedError {
+    name;
+    message;
+    __type = 'Error';
+    constructor(name, message) {
+        this.name = name;
+        this.message = message;
+    }
+}
+exports.SerializedError = SerializedError;
+//# sourceMappingURL=RecordSerializer.js.map

package/src/http/recorder/RecordSerializer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecordSerializer.js","sourceRoot":"","sources":["../../../../../../../packages/core/core-util/src/http/recorder/RecordSerializer.ts"],"names":[],"mappings":";;;AAAA,+CAAqD;AAErD;;;;;;;;;;;GAWG;AACH,MAAa,gBAAgB;IACzB;;OAEG;IACH,iFAAiF;IACjF,SAAS,CAAC,KAAc;QACpB,0EAA0E;QAC1E,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,UAAqB,GAAW,EAAE,GAAY;YACvE,qEAAqE;YACrE,IAAI,GAAG,KAAK,EAAE,IAAI,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;gBACzE,MAAM,OAAO,GAAG,IAAA,kCAAoB,EAAC,IAAI,CAAC,CAAC;gBAC3C,IAAI,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;oBACxB,OAAO,SAAS,CAAC;gBACrB,CAAC;YACL,CAAC;YACD,IAAI,GAAG,YAAY,GAAG,EAAE,CAAC;gBACrB,OAAO,IAAI,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;YACxD,CAAC;YACD,IAAI,GAAG,YAAY,KAAK,EAAE,CAAC;gBACvB,OAAO,IAAI,eAAe,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;YACtD,CAAC;YACD,OAAO,GAAG,CAAC;QACf,CAAC,EAAE,CAAC,CAAC,CAAC;IACV,CAAC;IAED;;OAEG;IACH,WAAW,CAAI,IAAY;QACvB,yEAAyE;QACzE,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,GAAW,EAAE,GAAY,EAAW,EAAE;YAC3D,IAAI,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAK,GAAqB,CAAC,MAAM,KAAK,KAAK,EAAE,CAAC;gBAC5E,OAAO,IAAI,GAAG,CAAE,GAAqB,CAAC,OAAO,CAAC,CAAC;YACnD,CAAC;YACD,OAAO,GAAG,CAAC;QACf,CAAC,CAAM,CAAC;IACZ,CAAC;CACJ;AArCD,4CAqCC;AAED;;GAEG;AACH,MAAa,aAAa;IAGM;IAFnB,MAAM,GAAG,KAAK,CAAC;IACxB,kFAAkF;IAClF,YAA4B,OAA6B;QAA7B,YAAO,GAAP,OAAO,CAAsB;IAAG,CAAC;CAChE;AAJD,sCAIC;AAED;;GAEG;AACH,MAAa,eAAe;IAGJ;IACA;IAHX,MAAM,GAAG,OAAO,CAAC;IAC1B,YACoB,IAAY,EACZ,OAAe;QADf,SAAI,GAAJ,IAAI,CAAQ;QACZ,YAAO,GAAP,OAAO,CAAQ;IAChC,CAAC;CACP;AAND,0CAMC","sourcesContent":["import { getDoNotRecordFields } from './DoNotRecord';\n\n/**\n * RecordSerializer - JSON (de)serialization for recorded fixtures.\n *\n * Handles the cases plain JSON.stringify gets wrong for test fixtures:\n * - Map values -> { __type: 'Map', entries: [...] } (revived back to Map)\n * - Error values -> { __type: 'Error', name, message }\n * - Fields marked @DoNotRecord on class DTOs are omitted\n * - Dates serialize to ISO strings naturally (Date.prototype.toJSON)\n *\n * Fixtures stay diffable, human-editable JSON - the stable artifact that a\n * generated spec (or an AI writing a spec) consumes.\n */\nexport class RecordSerializer {\n    /**\n     * Serialize a recorded value/test case to pretty-printed JSON.\n     */\n    // webpieces-disable no-any-unknown -- serializer accepts arbitrary recorded DTOs\n    serialize(value: unknown): string {\n        // webpieces-disable no-any-unknown -- JSON replacer is inherently untyped\n        return JSON.stringify(value, function (this: any, key: string, val: unknown): unknown {\n            // `this` is the object containing `key` - consult @DoNotRecord on it\n            if (key !== '' && this && typeof this === 'object' && !Array.isArray(this)) {\n                const skipped = getDoNotRecordFields(this);\n                if (skipped.includes(key)) {\n                    return undefined;\n                }\n            }\n            if (val instanceof Map) {\n                return new SerializedMap(Array.from(val.entries()));\n            }\n            if (val instanceof Error) {\n                return new SerializedError(val.name, val.message);\n            }\n            return val;\n        }, 2);\n    }\n\n    /**\n     * Parse fixture JSON back, reviving Map markers.\n     */\n    deserialize<T>(json: string): T {\n        // webpieces-disable no-any-unknown -- JSON reviver is inherently untyped\n        return JSON.parse(json, (key: string, val: unknown): unknown => {\n            if (val && typeof val === 'object' && (val as SerializedMap).__type === 'Map') {\n                return new Map((val as SerializedMap).entries);\n            }\n            return val;\n        }) as T;\n    }\n}\n\n/**\n * Wire format for Map values inside fixtures.\n */\nexport class SerializedMap {\n    readonly __type = 'Map';\n    // webpieces-disable no-any-unknown -- Map entries carry arbitrary recorded values\n    constructor(public readonly entries: [unknown, unknown][]) {}\n}\n\n/**\n * Wire format for Error values inside fixtures.\n */\nexport class SerializedError {\n    readonly __type = 'Error';\n    constructor(\n        public readonly name: string,\n        public readonly message: string,\n    ) {}\n}\n"]}

package/src/http/recorder/RecordedEndpoint.d.ts

@@ -0,0 +1,49 @@
+/**
+ * RecordedError - Serializable capture of a thrown error.
+ * Per CLAUDE.md: data-only structure = class.
+ */
+export declare class RecordedError {
+    readonly name: string;
+    readonly message: string;
+    constructor(name: string, message: string);
+}
+/**
+ * RecordedEndpoint - One captured API invocation (port of Java EndpointInfo).
+ *
+ * Captures the server endpoint that was hit OR a downstream call made while
+ * serving it (outbound HTTP client call or in-process recordable() api).
+ */
+export declare class RecordedEndpoint {
+    /** Api class name, e.g. 'SaveApi' or 'RemoteApi'. */
+    readonly apiName: string;
+    /** Method invoked, e.g. 'save'. */
+    readonly methodName: string;
+    /** Arguments passed (the request DTO(s)). */
+    readonly args: unknown[];
+    /** Masked snapshot of the magic context headers at call time. */
+    readonly ctxSnapshot?: Record<string, string> | undefined;
+    /** Response returned on success (JSON-serializable DTO). */
+    successResponse?: unknown;
+    /** Error thrown on failure. */
+    failureResponse?: RecordedError;
+    constructor(
+    /** Api class name, e.g. 'SaveApi' or 'RemoteApi'. */
+    apiName: string, 
+    /** Method invoked, e.g. 'save'. */
+    methodName: string, 
+    /** Arguments passed (the request DTO(s)). */
+    args: unknown[], 
+    /** Masked snapshot of the magic context headers at call time. */
+    ctxSnapshot?: Record<string, string> | undefined);
+}
+/**
+ * RecordedTestCase - The full capture for one inbound request: the server
+ * endpoint plus every downstream call it triggered (which become the mocks
+ * in the generated test).
+ */
+export declare class RecordedTestCase {
+    readonly serverEndpoint: RecordedEndpoint;
+    readonly downstreamCalls: RecordedEndpoint[];
+    readonly recordedAt: string;
+    constructor(serverEndpoint: RecordedEndpoint, downstreamCalls: RecordedEndpoint[], recordedAt: string);
+}

package/src/http/recorder/RecordedEndpoint.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecordedTestCase = exports.RecordedEndpoint = exports.RecordedError = void 0;
+/**
+ * RecordedError - Serializable capture of a thrown error.
+ * Per CLAUDE.md: data-only structure = class.
+ */
+class RecordedError {
+    name;
+    message;
+    constructor(name, message) {
+        this.name = name;
+        this.message = message;
+    }
+}
+exports.RecordedError = RecordedError;
+/**
+ * RecordedEndpoint - One captured API invocation (port of Java EndpointInfo).
+ *
+ * Captures the server endpoint that was hit OR a downstream call made while
+ * serving it (outbound HTTP client call or in-process recordable() api).
+ */
+class RecordedEndpoint {
+    apiName;
+    methodName;
+    args;
+    ctxSnapshot;
+    /** Response returned on success (JSON-serializable DTO). */
+    // webpieces-disable no-any-unknown -- recorded DTOs are api-specific, erased here
+    successResponse;
+    /** Error thrown on failure. */
+    failureResponse;
+    constructor(
+    /** Api class name, e.g. 'SaveApi' or 'RemoteApi'. */
+    apiName, 
+    /** Method invoked, e.g. 'save'. */
+    methodName, 
+    /** Arguments passed (the request DTO(s)). */
+    // webpieces-disable no-any-unknown -- recorded DTOs are api-specific, erased here
+    args, 
+    /** Masked snapshot of the magic context headers at call time. */
+    ctxSnapshot) {
+        this.apiName = apiName;
+        this.methodName = methodName;
+        this.args = args;
+        this.ctxSnapshot = ctxSnapshot;
+    }
+}
+exports.RecordedEndpoint = RecordedEndpoint;
+/**
+ * RecordedTestCase - The full capture for one inbound request: the server
+ * endpoint plus every downstream call it triggered (which become the mocks
+ * in the generated test).
+ */
+class RecordedTestCase {
+    serverEndpoint;
+    downstreamCalls;
+    recordedAt;
+    constructor(serverEndpoint, downstreamCalls, recordedAt) {
+        this.serverEndpoint = serverEndpoint;
+        this.downstreamCalls = downstreamCalls;
+        this.recordedAt = recordedAt;
+    }
+}
+exports.RecordedTestCase = RecordedTestCase;
+//# sourceMappingURL=RecordedEndpoint.js.map

package/src/http/recorder/RecordedEndpoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecordedEndpoint.js","sourceRoot":"","sources":["../../../../../../../packages/core/core-util/src/http/recorder/RecordedEndpoint.ts"],"names":[],"mappings":";;;AAAA;;;GAGG;AACH,MAAa,aAAa;IAEF;IACA;IAFpB,YACoB,IAAY,EACZ,OAAe;QADf,SAAI,GAAJ,IAAI,CAAQ;QACZ,YAAO,GAAP,OAAO,CAAQ;IAChC,CAAC;CACP;AALD,sCAKC;AAED;;;;;GAKG;AACH,MAAa,gBAAgB;IAUL;IAEA;IAGA;IAEA;IAhBpB,4DAA4D;IAC5D,kFAAkF;IAC3E,eAAe,CAAW;IAEjC,+BAA+B;IACxB,eAAe,CAAiB;IAEvC;IACI,qDAAqD;IACrC,OAAe;IAC/B,mCAAmC;IACnB,UAAkB;IAClC,6CAA6C;IAC7C,kFAAkF;IAClE,IAAe;IAC/B,iEAAiE;IACjD,WAAoC;QAPpC,YAAO,GAAP,OAAO,CAAQ;QAEf,eAAU,GAAV,UAAU,CAAQ;QAGlB,SAAI,GAAJ,IAAI,CAAW;QAEf,gBAAW,GAAX,WAAW,CAAyB;IACrD,CAAC;CACP;AAnBD,4CAmBC;AAED;;;;GAIG;AACH,MAAa,gBAAgB;IAEL;IACA;IACA;IAHpB,YACoB,cAAgC,EAChC,eAAmC,EACnC,UAAkB;QAFlB,mBAAc,GAAd,cAAc,CAAkB;QAChC,oBAAe,GAAf,eAAe,CAAoB;QACnC,eAAU,GAAV,UAAU,CAAQ;IACnC,CAAC;CACP;AAND,4CAMC","sourcesContent":["/**\n * RecordedError - Serializable capture of a thrown error.\n * Per CLAUDE.md: data-only structure = class.\n */\nexport class RecordedError {\n    constructor(\n        public readonly name: string,\n        public readonly message: string,\n    ) {}\n}\n\n/**\n * RecordedEndpoint - One captured API invocation (port of Java EndpointInfo).\n *\n * Captures the server endpoint that was hit OR a downstream call made while\n * serving it (outbound HTTP client call or in-process recordable() api).\n */\nexport class RecordedEndpoint {\n    /** Response returned on success (JSON-serializable DTO). */\n    // webpieces-disable no-any-unknown -- recorded DTOs are api-specific, erased here\n    public successResponse?: unknown;\n\n    /** Error thrown on failure. */\n    public failureResponse?: RecordedError;\n\n    constructor(\n        /** Api class name, e.g. 'SaveApi' or 'RemoteApi'. */\n        public readonly apiName: string,\n        /** Method invoked, e.g. 'save'. */\n        public readonly methodName: string,\n        /** Arguments passed (the request DTO(s)). */\n        // webpieces-disable no-any-unknown -- recorded DTOs are api-specific, erased here\n        public readonly args: unknown[],\n        /** Masked snapshot of the magic context headers at call time. */\n        public readonly ctxSnapshot?: Record<string, string>,\n    ) {}\n}\n\n/**\n * RecordedTestCase - The full capture for one inbound request: the server\n * endpoint plus every downstream call it triggered (which become the mocks\n * in the generated test).\n */\nexport class RecordedTestCase {\n    constructor(\n        public readonly serverEndpoint: RecordedEndpoint,\n        public readonly downstreamCalls: RecordedEndpoint[],\n        public readonly recordedAt: string,\n    ) {}\n}\n"]}