@webiny/api-core 6.5.0-beta.1 → 6.5.0-beta.3

package/ApiCoreFeature.js

@@ -8,6 +8,7 @@ import { AdminUsersFeature } from "./features/users/AdminUsersFeature.js";
 import { IdpAuthenticatorFeature } from "./idp/feature.js";
 import { KeyValueStoreFeature } from "./features/keyValueStore/feature.js";
 import { BuildParamsFeature } from "./features/buildParams/feature.js";
+import { DebuggerFeature } from "./features/debugger/feature.js";
 import { EncryptionFeature } from "./features/encryption/feature.js";
 import { FeatureFlagsFeature } from "./features/featureFlags/feature.js";
 import { MaskerFeature } from "./features/masker/feature.js";
@@ -22,6 +23,7 @@ const ApiCoreFeature = createFeature({
         LoggerFeature.register(container);
         EventPublisherFeature.register(container);
         BuildParamsFeature.register(container);
+        DebuggerFeature.register(container);
         EncryptionFeature.register(container);
         FeatureFlagsFeature.register(container);
         TenancyFeature.register(container, config.tenancyStorageOperations);

package/ApiCoreFeature.js.map

@@ -1 +1 @@
-{"version":3,"file":"ApiCoreFeature.js","sources":["../src/ApiCoreFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { Container } from \"@webiny/di\";\nimport { EventPublisherFeature } from \"~/features/eventPublisher/feature.js\";\nimport { LoggerFeature } from \"~/features/logger/feature.js\";\nimport { SecurityFeature } from \"~/features/security/SecurityFeature.js\";\nimport { SystemFeature } from \"~/features/system/SystemFeature.js\";\nimport { TenancyFeature } from \"./features/tenancy/TenancyFeature.js\";\nimport { AdminUsersFeature } from \"~/features/users/AdminUsersFeature.js\";\nimport type { ApiCoreStorageOperations } from \"~/types/core.js\";\nimport { IdpAuthenticatorFeature } from \"~/idp/feature.js\";\nimport { KeyValueStoreFeature } from \"~/features/keyValueStore/feature.js\";\nimport { BuildParamsFeature } from \"~/features/buildParams/feature.js\";\nimport { EncryptionFeature } from \"~/features/encryption/feature.js\";\nimport { FeatureFlagsFeature } from \"~/features/featureFlags/feature.js\";\nimport { MaskerFeature } from \"~/features/masker/feature.js\";\nimport { AiFeature } from \"~/features/ai/feature.js\";\nimport { NullWebhookDispatcher } from \"./features/webhooks/WebhookDispatcher/NullWebhookDispatcher.js\";\nimport { WebhookProviderFeature } from \"~/features/webhooks/index.js\";\n\nexport const ApiCoreFeature = createFeature({\n    name: \"ApiCore\",\n    register(container: Container, config: ApiCoreStorageOperations) {\n        // Register features\n        MaskerFeature.register(container);\n        AiFeature.register(container);\n        LoggerFeature.register(container);\n        EventPublisherFeature.register(container);\n        BuildParamsFeature.register(container);\n        EncryptionFeature.register(container);\n        FeatureFlagsFeature.register(container);\n        TenancyFeature.register(container, config.tenancyStorageOperations);\n        SecurityFeature.register(container, config.securityStorageOperations);\n        AdminUsersFeature.register(container, config.usersStorageOperations);\n        KeyValueStoreFeature.register(container, config.keyValueStorageOperations);\n        SystemFeature.register(container);\n        IdpAuthenticatorFeature.register(container);\n        container.register(NullWebhookDispatcher).inSingletonScope();\n        WebhookProviderFeature.register(container);\n    }\n});\n"],"names":["ApiCoreFeature","createFeature","container","config","MaskerFeature","AiFeature","LoggerFeature","EventPublisherFeature","BuildParamsFeature","EncryptionFeature","FeatureFlagsFeature","TenancyFeature","SecurityFeature","AdminUsersFeature","KeyValueStoreFeature","SystemFeature","IdpAuthenticatorFeature","NullWebhookDispatcher","WebhookProviderFeature"],"mappings":";;;;;;;;;;;;;;;;AAmBO,MAAMA,iBAAiBC,cAAc;IACxC,MAAM;IACN,UAASC,SAAoB,EAAEC,MAAgC;QAE3DC,cAAc,QAAQ,CAACF;QACvBG,UAAU,QAAQ,CAACH;QACnBI,cAAc,QAAQ,CAACJ;QACvBK,sBAAsB,QAAQ,CAACL;QAC/BM,mBAAmB,QAAQ,CAACN;QAC5BO,kBAAkB,QAAQ,CAACP;QAC3BQ,oBAAoB,QAAQ,CAACR;QAC7BS,eAAe,QAAQ,CAACT,WAAWC,OAAO,wBAAwB;QAClES,gBAAgB,QAAQ,CAACV,WAAWC,OAAO,yBAAyB;QACpEU,kBAAkB,QAAQ,CAACX,WAAWC,OAAO,sBAAsB;QACnEW,qBAAqB,QAAQ,CAACZ,WAAWC,OAAO,yBAAyB;QACzEY,cAAc,QAAQ,CAACb;QACvBc,wBAAwB,QAAQ,CAACd;QACjCA,UAAU,QAAQ,CAACe,uBAAuB,gBAAgB;QAC1DC,uBAAuB,QAAQ,CAAChB;IACpC;AACJ"}
+{"version":3,"file":"ApiCoreFeature.js","sources":["../src/ApiCoreFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { Container } from \"@webiny/di\";\nimport { EventPublisherFeature } from \"~/features/eventPublisher/feature.js\";\nimport { LoggerFeature } from \"~/features/logger/feature.js\";\nimport { SecurityFeature } from \"~/features/security/SecurityFeature.js\";\nimport { SystemFeature } from \"~/features/system/SystemFeature.js\";\nimport { TenancyFeature } from \"./features/tenancy/TenancyFeature.js\";\nimport { AdminUsersFeature } from \"~/features/users/AdminUsersFeature.js\";\nimport type { ApiCoreStorageOperations } from \"~/types/core.js\";\nimport { IdpAuthenticatorFeature } from \"~/idp/feature.js\";\nimport { KeyValueStoreFeature } from \"~/features/keyValueStore/feature.js\";\nimport { BuildParamsFeature } from \"~/features/buildParams/feature.js\";\nimport { DebuggerFeature } from \"~/features/debugger/feature.js\";\nimport { EncryptionFeature } from \"~/features/encryption/feature.js\";\nimport { FeatureFlagsFeature } from \"~/features/featureFlags/feature.js\";\nimport { MaskerFeature } from \"~/features/masker/feature.js\";\nimport { AiFeature } from \"~/features/ai/feature.js\";\nimport { NullWebhookDispatcher } from \"./features/webhooks/WebhookDispatcher/NullWebhookDispatcher.js\";\nimport { WebhookProviderFeature } from \"~/features/webhooks/index.js\";\n\nexport const ApiCoreFeature = createFeature({\n    name: \"ApiCore\",\n    register(container: Container, config: ApiCoreStorageOperations) {\n        // Register features\n        MaskerFeature.register(container);\n        AiFeature.register(container);\n        LoggerFeature.register(container);\n        EventPublisherFeature.register(container);\n        BuildParamsFeature.register(container);\n        DebuggerFeature.register(container);\n        EncryptionFeature.register(container);\n        FeatureFlagsFeature.register(container);\n        TenancyFeature.register(container, config.tenancyStorageOperations);\n        SecurityFeature.register(container, config.securityStorageOperations);\n        AdminUsersFeature.register(container, config.usersStorageOperations);\n        KeyValueStoreFeature.register(container, config.keyValueStorageOperations);\n        SystemFeature.register(container);\n        IdpAuthenticatorFeature.register(container);\n        container.register(NullWebhookDispatcher).inSingletonScope();\n        WebhookProviderFeature.register(container);\n    }\n});\n"],"names":["ApiCoreFeature","createFeature","container","config","MaskerFeature","AiFeature","LoggerFeature","EventPublisherFeature","BuildParamsFeature","DebuggerFeature","EncryptionFeature","FeatureFlagsFeature","TenancyFeature","SecurityFeature","AdminUsersFeature","KeyValueStoreFeature","SystemFeature","IdpAuthenticatorFeature","NullWebhookDispatcher","WebhookProviderFeature"],"mappings":";;;;;;;;;;;;;;;;;AAoBO,MAAMA,iBAAiBC,cAAc;IACxC,MAAM;IACN,UAASC,SAAoB,EAAEC,MAAgC;QAE3DC,cAAc,QAAQ,CAACF;QACvBG,UAAU,QAAQ,CAACH;QACnBI,cAAc,QAAQ,CAACJ;QACvBK,sBAAsB,QAAQ,CAACL;QAC/BM,mBAAmB,QAAQ,CAACN;QAC5BO,gBAAgB,QAAQ,CAACP;QACzBQ,kBAAkB,QAAQ,CAACR;QAC3BS,oBAAoB,QAAQ,CAACT;QAC7BU,eAAe,QAAQ,CAACV,WAAWC,OAAO,wBAAwB;QAClEU,gBAAgB,QAAQ,CAACX,WAAWC,OAAO,yBAAyB;QACpEW,kBAAkB,QAAQ,CAACZ,WAAWC,OAAO,sBAAsB;QACnEY,qBAAqB,QAAQ,CAACb,WAAWC,OAAO,yBAAyB;QACzEa,cAAc,QAAQ,CAACd;QACvBe,wBAAwB,QAAQ,CAACf;QACjCA,UAAU,QAAQ,CAACgB,uBAAuB,gBAAgB;QAC1DC,uBAAuB,QAAQ,CAACjB;IACpC;AACJ"}

package/createApiCore.d.ts

@@ -4,4 +4,4 @@ export interface ApiCoreConfig {
     storageOperations: ApiCoreStorageOperations;
     testProjectLicense?: DecryptedWcpProjectLicense;
 }
-export declare const createApiCore: (config: ApiCoreConfig) => (import("@webiny/api/index.js").ContextPlugin<import("~/types/core.js").ApiCoreContext>[] | import("@webiny/api/index.js").ContextPlugin<import("~/types/core.js").ApiCoreContext> | import("@webiny/handler-graphql/index.js").GraphQLSchemaPlugin<import("@webiny/api/types.js").Context> | import("@webiny/handler/index.js").RegisterExtensionPlugin<import("@webiny/handler/types.js").Context>)[];
+export declare const createApiCore: (config: ApiCoreConfig) => (import("@webiny/api/index.js").ContextPlugin<import("~/types/core.js").ApiCoreContext>[] | import("@webiny/api/index.js").ContextPlugin<import("~/types/core.js").ApiCoreContext> | import("@webiny/handler-graphql/index.js").GraphQLSchemaPlugin<import("@webiny/api/types.js").Context> | import("@webiny/plugins/types.js").PluginCollection | import("@webiny/plugins/types.js").PluginFactory | import("@webiny/handler/index.js").RegisterExtensionPlugin<import("@webiny/handler/types.js").Context> | import("@webiny/plugins/types.js").Plugin<Record<string, any>>)[];

package/createApiCore.js

@@ -5,6 +5,7 @@ import { createSecurityContext } from "./legacy/security/createSecurityContext.j
 import { createAdminUsersContext } from "./legacy/users/createAdminUsersContext.js";
 import { createTenancyContext } from "./legacy/tenancy/createTenancyContext.js";
 import { createSystemGraphQL } from "./graphql/system/createSystemGraphQL.js";
+import { createDebuggerPlugins } from "./features/debugger/index.js";
 const createApiCore = (config)=>{
     const plugin = createRegisterExtensionPlugin((context)=>{
         ApiCoreFeature.register(context.container, config.storageOperations);
@@ -18,7 +19,8 @@ const createApiCore = (config)=>{
         createTenancyContext(),
         createSecurityContext(),
         createAdminUsersContext(),
-        createSystemGraphQL()
+        createSystemGraphQL(),
+        ...createDebuggerPlugins()
     ];
 };
 export { createApiCore };

package/createApiCore.js.map

@@ -1 +1 @@
-{"version":3,"file":"createApiCore.js","sources":["../src/createApiCore.ts"],"sourcesContent":["import { createRegisterExtensionPlugin } from \"@webiny/handler/plugins/RegisterExtensionPlugin.js\";\nimport { ApiCoreFeature } from \"./ApiCoreFeature.js\";\nimport type { DecryptedWcpProjectLicense } from \"@webiny/wcp/types.js\";\nimport { createWcpContext } from \"~/legacy/wcp/context.js\";\nimport { createSecurityContext } from \"~/legacy/security/createSecurityContext.js\";\nimport { createAdminUsersContext } from \"~/legacy/users/createAdminUsersContext.js\";\nimport { createTenancyContext } from \"~/legacy/tenancy/createTenancyContext.js\";\nimport { createSystemGraphQL } from \"~/graphql/system/createSystemGraphQL.js\";\nimport type { ApiCoreStorageOperations } from \"~/types/core.js\";\n\nexport interface ApiCoreConfig {\n    storageOperations: ApiCoreStorageOperations;\n    testProjectLicense?: DecryptedWcpProjectLicense;\n}\n\nexport const createApiCore = (config: ApiCoreConfig) => {\n    const plugin = createRegisterExtensionPlugin(context => {\n        ApiCoreFeature.register(context.container, config.storageOperations);\n    });\n    plugin.name = \"apiCore.extension\";\n\n    return [\n        plugin,\n        createWcpContext({ testProjectLicense: config.testProjectLicense }),\n        createTenancyContext(),\n        createSecurityContext(),\n        createAdminUsersContext(),\n        createSystemGraphQL()\n    ];\n};\n"],"names":["createApiCore","config","plugin","createRegisterExtensionPlugin","context","ApiCoreFeature","createWcpContext","createTenancyContext","createSecurityContext","createAdminUsersContext","createSystemGraphQL"],"mappings":";;;;;;;AAeO,MAAMA,gBAAgB,CAACC;IAC1B,MAAMC,SAASC,8BAA8BC,CAAAA;QACzCC,eAAe,QAAQ,CAACD,QAAQ,SAAS,EAAEH,OAAO,iBAAiB;IACvE;IACAC,OAAO,IAAI,GAAG;IAEd,OAAO;QACHA;QACAI,iBAAiB;YAAE,oBAAoBL,OAAO,kBAAkB;QAAC;QACjEM;QACAC;QACAC;QACAC;KACH;AACL"}
+{"version":3,"file":"createApiCore.js","sources":["../src/createApiCore.ts"],"sourcesContent":["import { createRegisterExtensionPlugin } from \"@webiny/handler/plugins/RegisterExtensionPlugin.js\";\nimport { ApiCoreFeature } from \"./ApiCoreFeature.js\";\nimport type { DecryptedWcpProjectLicense } from \"@webiny/wcp/types.js\";\nimport { createWcpContext } from \"~/legacy/wcp/context.js\";\nimport { createSecurityContext } from \"~/legacy/security/createSecurityContext.js\";\nimport { createAdminUsersContext } from \"~/legacy/users/createAdminUsersContext.js\";\nimport { createTenancyContext } from \"~/legacy/tenancy/createTenancyContext.js\";\nimport { createSystemGraphQL } from \"~/graphql/system/createSystemGraphQL.js\";\nimport type { ApiCoreStorageOperations } from \"~/types/core.js\";\nimport { createDebuggerPlugins } from \"~/features/debugger/index.js\";\n\nexport interface ApiCoreConfig {\n    storageOperations: ApiCoreStorageOperations;\n    testProjectLicense?: DecryptedWcpProjectLicense;\n}\n\nexport const createApiCore = (config: ApiCoreConfig) => {\n    const plugin = createRegisterExtensionPlugin(context => {\n        ApiCoreFeature.register(context.container, config.storageOperations);\n    });\n    plugin.name = \"apiCore.extension\";\n\n    return [\n        plugin,\n        createWcpContext({ testProjectLicense: config.testProjectLicense }),\n        createTenancyContext(),\n        createSecurityContext(),\n        createAdminUsersContext(),\n        createSystemGraphQL(),\n        ...createDebuggerPlugins()\n    ];\n};\n"],"names":["createApiCore","config","plugin","createRegisterExtensionPlugin","context","ApiCoreFeature","createWcpContext","createTenancyContext","createSecurityContext","createAdminUsersContext","createSystemGraphQL","createDebuggerPlugins"],"mappings":";;;;;;;;AAgBO,MAAMA,gBAAgB,CAACC;IAC1B,MAAMC,SAASC,8BAA8BC,CAAAA;QACzCC,eAAe,QAAQ,CAACD,QAAQ,SAAS,EAAEH,OAAO,iBAAiB;IACvE;IACAC,OAAO,IAAI,GAAG;IAEd,OAAO;QACHA;QACAI,iBAAiB;YAAE,oBAAoBL,OAAO,kBAAkB;QAAC;QACjEM;QACAC;QACAC;QACAC;WACGC;KACN;AACL"}

package/features/debugger/Debugger.d.ts

@@ -0,0 +1,23 @@
+import { Debugger as DebuggerAbstraction, DebuggerTransport, type DebugNamespace, type IDebugDeliveryTarget, type IDebuggerStartParams, type IDebugPayloadFactory } from "./abstractions.js";
+import { IdentityContext } from "../../features/security/IdentityContext/index.js";
+import { BuildParams } from "../../features/buildParams/index.js";
+export declare class DebuggerImpl implements DebuggerAbstraction.Interface {
+    private readonly identityContext;
+    private readonly buildParams;
+    private readonly transports;
+    private session;
+    private readonly limits;
+    constructor(identityContext: IdentityContext.Interface, buildParams: BuildParams.Interface, transports: DebuggerTransport.Interface[]);
+    start(params: IDebuggerStartParams): void;
+    isEnabled(namespace: DebugNamespace): boolean;
+    log(namespace: DebugNamespace, payload: IDebugPayloadFactory): void;
+    flush(target: IDebugDeliveryTarget): Promise<void>;
+    discard(): void;
+    private isDisabled;
+    /**
+     * Drops entries from the front until the session fits the byte budget. The client reproduces the
+     * bug, so the failure is at the end of the session and the tail is what matters.
+     */
+    private enforceBudget;
+}
+export declare const Debugger: import("@webiny/di").Implementation<typeof DebuggerImpl>;

package/features/debugger/Debugger.js

@@ -0,0 +1,134 @@
+import { createImplementation } from "@webiny/feature/api";
+import { Debugger, DebuggerTransport } from "./abstractions.js";
+import { IdentityContext } from "../security/IdentityContext/index.js";
+import { BuildParams } from "../buildParams/index.js";
+import { createNamespaceFilter } from "./matchNamespace.js";
+import { DEFAULT_LIMITS } from "./limits.js";
+import { serialize } from "./serialize.js";
+const FLUSH_TIMEOUT_MS = 2000;
+const describeError = (error)=>{
+    if (error instanceof Error) return `${error.name}: ${error.message}`;
+    return "Unknown error.";
+};
+class DebuggerImpl {
+    constructor(identityContext, buildParams, transports){
+        this.identityContext = identityContext;
+        this.buildParams = buildParams;
+        this.transports = transports;
+        this.session = void 0;
+        this.limits = DEFAULT_LIMITS;
+    }
+    start(params) {
+        if (this.isDisabled()) return;
+        if (0 === params.namespaces.length) return;
+        this.session = {
+            namespaces: params.namespaces,
+            filter: createNamespaceFilter(params.namespaces),
+            startedAt: Date.now(),
+            entries: [],
+            bytes: 0,
+            dropped: 0,
+            truncated: false,
+            seq: 0
+        };
+    }
+    isEnabled(namespace) {
+        const session = this.session;
+        if (!session) return false;
+        if (this.identityContext.getIdentity().isAnonymous()) return false;
+        return session.filter.matches(namespace);
+    }
+    log(namespace, payload) {
+        try {
+            const session = this.session;
+            if (!session || !this.isEnabled(namespace)) return;
+            if (session.entries.length >= this.limits.entryCount) return;
+            const { json, bytes, truncated } = serialize(payload(), this.limits);
+            const entry = {
+                seq: ++session.seq,
+                namespace,
+                timestamp: Date.now(),
+                elapsed: Date.now() - session.startedAt,
+                json,
+                bytes
+            };
+            session.entries.push(entry);
+            session.bytes += bytes;
+            session.truncated = session.truncated || truncated;
+            this.enforceBudget(session);
+        } catch (ex) {
+            console.error(`Debugger failed to capture "${namespace}".`, describeError(ex));
+        }
+    }
+    async flush(target) {
+        const session = this.session;
+        this.session = void 0;
+        if (!session) return;
+        const transports = this.transports.filter((transport)=>{
+            try {
+                return transport.canDeliver(target);
+            } catch  {
+                return false;
+            }
+        });
+        if (0 === transports.length) return;
+        const frozen = Object.freeze({
+            namespaces: session.namespaces,
+            startedAt: session.startedAt,
+            entries: session.entries,
+            bytes: session.bytes,
+            dropped: session.dropped,
+            truncated: session.truncated
+        });
+        const delivery = Promise.allSettled(transports.map(async (transport)=>await transport.deliver({
+                target,
+                session: frozen
+            })));
+        let timer;
+        const timeout = new Promise((resolve)=>{
+            timer = setTimeout(resolve, FLUSH_TIMEOUT_MS);
+        });
+        try {
+            const results = await Promise.race([
+                delivery,
+                timeout
+            ]);
+            if (Array.isArray(results)) {
+                for (const result of results)if ("rejected" === result.status) console.error("Debugger transport failed to deliver.", describeError(result.reason));
+            }
+        } finally{
+            if (timer) clearTimeout(timer);
+        }
+    }
+    discard() {
+        this.session = void 0;
+    }
+    isDisabled() {
+        return true === this.buildParams.get("DebuggerDisabled");
+    }
+    enforceBudget(session) {
+        while(session.bytes > this.limits.totalBytes && session.entries.length > 0){
+            const removed = session.entries.shift();
+            if (!removed) break;
+            session.bytes -= removed.bytes;
+            session.dropped++;
+        }
+    }
+}
+const Debugger_Debugger = createImplementation({
+    abstraction: Debugger,
+    implementation: DebuggerImpl,
+    dependencies: [
+        IdentityContext,
+        BuildParams,
+        [
+            DebuggerTransport,
+            {
+                multiple: true
+            }
+        ]
+    ]
+});
+export { DebuggerImpl, Debugger_Debugger as Debugger };
+
+//# sourceMappingURL=Debugger.js.map

package/features/debugger/Debugger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/debugger/Debugger.js","sources":["../../../src/features/debugger/Debugger.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/feature/api\";\nimport {\n    Debugger as DebuggerAbstraction,\n    DebuggerTransport,\n    type DebugNamespace,\n    type IDebugDeliveryTarget,\n    type IDebugEntry,\n    type IDebuggerStartParams,\n    type IDebugPayloadFactory,\n    type IDebugSession\n} from \"./abstractions.js\";\nimport { IdentityContext } from \"~/features/security/IdentityContext/index.js\";\nimport { BuildParams } from \"~/features/buildParams/index.js\";\nimport { createNamespaceFilter, type INamespaceFilter } from \"./matchNamespace.js\";\nimport { DEFAULT_LIMITS, type IDebuggerLimits } from \"./limits.js\";\nimport { serialize } from \"./serialize.js\";\n\nconst FLUSH_TIMEOUT_MS = 2000;\n\n/**\n * Renders an error for logging without touching anything that could hold a captured payload.\n *\n * Deliberately not `stringifyError` from `@webiny/handler`: that spreads the whole error object, so\n * an error carrying a `data` property would put debug payloads into CloudWatch - the one sink they\n * must never reach.\n */\nconst describeError = (error: unknown): string => {\n    if (error instanceof Error) {\n        return `${error.name}: ${error.message}`;\n    }\n    return \"Unknown error.\";\n};\n\ninterface IActiveSession extends IDebugSession {\n    filter: INamespaceFilter;\n    seq: number;\n}\n\nexport class DebuggerImpl implements DebuggerAbstraction.Interface {\n    private session: IActiveSession | undefined = undefined;\n    private readonly limits: IDebuggerLimits = DEFAULT_LIMITS;\n\n    public constructor(\n        private readonly identityContext: IdentityContext.Interface,\n        private readonly buildParams: BuildParams.Interface,\n        private readonly transports: DebuggerTransport.Interface[]\n    ) {}\n\n    public start(params: IDebuggerStartParams): void {\n        if (this.isDisabled()) {\n            return;\n        }\n\n        if (params.namespaces.length === 0) {\n            return;\n        }\n\n        /**\n         * Always replace. A session surviving into the next request would mean one identity\n         * receiving another's entries.\n         */\n        this.session = {\n            namespaces: params.namespaces,\n            filter: createNamespaceFilter(params.namespaces),\n            startedAt: Date.now(),\n            entries: [],\n            bytes: 0,\n            dropped: 0,\n            truncated: false,\n            seq: 0\n        };\n    }\n\n    public isEnabled(namespace: DebugNamespace): boolean {\n        const session = this.session;\n        if (!session) {\n            return false;\n        }\n\n        /**\n         * An anonymous identity must never accumulate payloads. The flush-time permission check is\n         * authoritative, but this earlier gate means there is nothing to leak if a future code path\n         * delivers a session without passing through it.\n         */\n        if (this.identityContext.getIdentity().isAnonymous()) {\n            return false;\n        }\n\n        return session.filter.matches(namespace);\n    }\n\n    public log(namespace: DebugNamespace, payload: IDebugPayloadFactory): void {\n        /**\n         * The debugger must never be able to break the request it is observing, and payload\n         * factories are written in a hurry during an incident.\n         */\n        try {\n            const session = this.session;\n            if (!session || !this.isEnabled(namespace)) {\n                return;\n            }\n\n            if (session.entries.length >= this.limits.entryCount) {\n                return;\n            }\n\n            /**\n             * Invoke and serialize immediately: this releases the closure and the payload graph, and\n             * it is what makes the entry's size known, which is what makes the budget enforceable.\n             */\n            const { json, bytes, truncated } = serialize(payload(), this.limits);\n\n            const entry: IDebugEntry = {\n                seq: ++session.seq,\n                namespace,\n                timestamp: Date.now(),\n                elapsed: Date.now() - session.startedAt,\n                json,\n                bytes\n            };\n\n            session.entries.push(entry);\n            session.bytes += bytes;\n            session.truncated = session.truncated || truncated;\n\n            this.enforceBudget(session);\n        } catch (ex) {\n            console.error(`Debugger failed to capture \"${namespace}\".`, describeError(ex));\n        }\n    }\n\n    public async flush(target: IDebugDeliveryTarget): Promise<void> {\n        const session = this.session;\n        this.session = undefined;\n\n        if (!session) {\n            return;\n        }\n\n        const transports = this.transports.filter(transport => {\n            try {\n                return transport.canDeliver(target);\n            } catch {\n                return false;\n            }\n        });\n\n        if (transports.length === 0) {\n            return;\n        }\n\n        const frozen = Object.freeze({\n            namespaces: session.namespaces,\n            startedAt: session.startedAt,\n            entries: session.entries,\n            bytes: session.bytes,\n            dropped: session.dropped,\n            truncated: session.truncated\n        }) as IDebugSession;\n\n        const delivery = Promise.allSettled(\n            transports.map(async transport => {\n                return await transport.deliver({ target, session: frozen });\n            })\n        );\n\n        /**\n         * In-memory delivery is instant, but a future network sink is not, and debug data is never\n         * worth making the app feel broken. The timer is cleared so it cannot hold the event loop\n         * open between the response and the Lambda freeze.\n         */\n        let timer: NodeJS.Timeout | undefined;\n        const timeout = new Promise<void>(resolve => {\n            timer = setTimeout(resolve, FLUSH_TIMEOUT_MS);\n        });\n\n        try {\n            const results = await Promise.race([delivery, timeout]);\n            if (Array.isArray(results)) {\n                for (const result of results) {\n                    if (result.status === \"rejected\") {\n                        /**\n                         * Only the error - never the session or any entry. `console.error` goes to\n                         * CloudWatch, which is the one place debug payloads must never reach.\n                         */\n                        console.error(\n                            \"Debugger transport failed to deliver.\",\n                            describeError(result.reason)\n                        );\n                    }\n                }\n            }\n        } finally {\n            if (timer) {\n                clearTimeout(timer);\n            }\n        }\n    }\n\n    public discard(): void {\n        this.session = undefined;\n    }\n\n    private isDisabled(): boolean {\n        return this.buildParams.get<boolean>(\"DebuggerDisabled\") === true;\n    }\n\n    /**\n     * Drops entries from the front until the session fits the byte budget. The client reproduces the\n     * bug, so the failure is at the end of the session and the tail is what matters.\n     */\n    private enforceBudget(session: IActiveSession): void {\n        while (session.bytes > this.limits.totalBytes && session.entries.length > 0) {\n            const removed = session.entries.shift();\n            if (!removed) {\n                break;\n            }\n            session.bytes -= removed.bytes;\n            session.dropped++;\n        }\n    }\n}\n\nexport const Debugger = createImplementation({\n    abstraction: DebuggerAbstraction,\n    implementation: DebuggerImpl,\n    dependencies: [IdentityContext, BuildParams, [DebuggerTransport, { multiple: true }]]\n});\n"],"names":["FLUSH_TIMEOUT_MS","describeError","error","Error","DebuggerImpl","identityContext","buildParams","transports","undefined","DEFAULT_LIMITS","params","createNamespaceFilter","Date","namespace","session","payload","json","bytes","truncated","serialize","entry","ex","console","target","transport","frozen","Object","delivery","Promise","timer","timeout","resolve","setTimeout","results","Array","result","clearTimeout","removed","Debugger","createImplementation","DebuggerAbstraction","IdentityContext","BuildParams","DebuggerTransport"],"mappings":"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"}

package/features/debugger/GraphQLDebuggerTransport.d.ts

@@ -0,0 +1,26 @@
+import { DebuggerTransport as DebuggerTransportAbstraction, type IDebugDeliveryTarget, type IDebuggerTransportDeliverParams } from "./abstractions.js";
+export declare const GRAPHQL_TARGET = "graphql";
+export interface IGraphQLDeliveryTarget extends IDebugDeliveryTarget {
+    type: typeof GRAPHQL_TARGET;
+    /**
+     * Already resolved to a single result object - never the array. Batched requests are reduced to
+     * their last element by the flush plugin, so this transport never has to know about batching.
+     */
+    result: Record<string, any>;
+    requestId: string;
+    operations: string[];
+    url: string;
+}
+/**
+ * Writes a finished session into the GraphQL response's `extensions` property.
+ */
+export declare class GraphQLDebuggerTransportImpl implements DebuggerTransportAbstraction.Interface {
+    canDeliver(target: IDebugDeliveryTarget): boolean;
+    deliver({ target, session }: IDebuggerTransportDeliverParams): void;
+}
+/**
+ * Merges a value under `extensions.debug`, never assigning `extensions` wholesale - other plugins
+ * write to it too.
+ */
+export declare const writeExtension: (result: Record<string, any>, debug: Record<string, any>) => void;
+export declare const GraphQLDebuggerTransport: import("@webiny/di").Implementation<typeof GraphQLDebuggerTransportImpl>;

package/features/debugger/GraphQLDebuggerTransport.js

@@ -0,0 +1,45 @@
+import { createImplementation } from "@webiny/feature/api";
+import { DebuggerTransport } from "./abstractions.js";
+const GRAPHQL_TARGET = "graphql";
+const isGraphQLTarget = (target)=>target.type === GRAPHQL_TARGET;
+class GraphQLDebuggerTransportImpl {
+    canDeliver(target) {
+        return isGraphQLTarget(target);
+    }
+    deliver({ target, session }) {
+        if (!isGraphQLTarget(target)) return;
+        if (0 === session.entries.length) return;
+        const entries = session.entries.map((entry)=>({
+                seq: entry.seq,
+                namespace: entry.namespace,
+                timestamp: entry.timestamp,
+                elapsed: entry.elapsed,
+                data: JSON.parse(entry.json)
+            }));
+        writeExtension(target.result, {
+            enabled: true,
+            requestId: target.requestId,
+            url: target.url,
+            namespaces: session.namespaces,
+            operations: target.operations,
+            entries,
+            bytes: session.bytes,
+            dropped: session.dropped,
+            truncated: session.truncated
+        });
+    }
+}
+const writeExtension = (result, debug)=>{
+    result.extensions = {
+        ...result.extensions,
+        debug
+    };
+};
+const GraphQLDebuggerTransport = createImplementation({
+    abstraction: DebuggerTransport,
+    implementation: GraphQLDebuggerTransportImpl,
+    dependencies: []
+});
+export { GRAPHQL_TARGET, GraphQLDebuggerTransport, GraphQLDebuggerTransportImpl, writeExtension };
+
+//# sourceMappingURL=GraphQLDebuggerTransport.js.map

package/features/debugger/GraphQLDebuggerTransport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/debugger/GraphQLDebuggerTransport.js","sources":["../../../src/features/debugger/GraphQLDebuggerTransport.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/feature/api\";\nimport {\n    DebuggerTransport as DebuggerTransportAbstraction,\n    type IDebugDeliveryTarget,\n    type IDebuggerTransportDeliverParams\n} from \"./abstractions.js\";\n\nexport const GRAPHQL_TARGET = \"graphql\";\n\nexport interface IGraphQLDeliveryTarget extends IDebugDeliveryTarget {\n    type: typeof GRAPHQL_TARGET;\n    /**\n     * Already resolved to a single result object - never the array. Batched requests are reduced to\n     * their last element by the flush plugin, so this transport never has to know about batching.\n     */\n    result: Record<string, any>;\n    requestId: string;\n    operations: string[];\n    url: string;\n}\n\nconst isGraphQLTarget = (target: IDebugDeliveryTarget): target is IGraphQLDeliveryTarget => {\n    return target.type === GRAPHQL_TARGET;\n};\n\n/**\n * Writes a finished session into the GraphQL response's `extensions` property.\n */\nexport class GraphQLDebuggerTransportImpl implements DebuggerTransportAbstraction.Interface {\n    public canDeliver(target: IDebugDeliveryTarget): boolean {\n        return isGraphQLTarget(target);\n    }\n\n    public deliver({ target, session }: IDebuggerTransportDeliverParams): void {\n        if (!isGraphQLTarget(target)) {\n            return;\n        }\n\n        /**\n         * Nothing matched the filter on this request. Writing an envelope with an empty `entries`\n         * array would put a payload on every response for no benefit, and give whoever reads the\n         * report a pile of blanks to scroll past.\n         */\n        if (session.entries.length === 0) {\n            return;\n        }\n\n        const entries = session.entries.map(entry => {\n            return {\n                seq: entry.seq,\n                namespace: entry.namespace,\n                timestamp: entry.timestamp,\n                elapsed: entry.elapsed,\n                /**\n                 * Entries are buffered as strings so the payload graph can be released at capture\n                 * time. Parsing here is what puts structured data in the response rather than JSON\n                 * inside JSON.\n                 */\n                data: JSON.parse(entry.json)\n            };\n        });\n\n        writeExtension(target.result, {\n            enabled: true,\n            requestId: target.requestId,\n            url: target.url,\n            namespaces: session.namespaces,\n            operations: target.operations,\n            entries,\n            bytes: session.bytes,\n            dropped: session.dropped,\n            truncated: session.truncated\n        });\n    }\n}\n\n/**\n * Merges a value under `extensions.debug`, never assigning `extensions` wholesale - other plugins\n * write to it too.\n */\nexport const writeExtension = (result: Record<string, any>, debug: Record<string, any>): void => {\n    result.extensions = { ...result.extensions, debug };\n};\n\nexport const GraphQLDebuggerTransport = createImplementation({\n    abstraction: DebuggerTransportAbstraction,\n    implementation: GraphQLDebuggerTransportImpl,\n    dependencies: []\n});\n"],"names":["GRAPHQL_TARGET","isGraphQLTarget","target","GraphQLDebuggerTransportImpl","session","entries","entry","JSON","writeExtension","result","debug","GraphQLDebuggerTransport","createImplementation","DebuggerTransportAbstraction"],"mappings":";;AAOO,MAAMA,iBAAiB;AAc9B,MAAMC,kBAAkB,CAACC,SACdA,OAAO,IAAI,KAAKF;AAMpB,MAAMG;IACF,WAAWD,MAA4B,EAAW;QACrD,OAAOD,gBAAgBC;IAC3B;IAEO,QAAQ,EAAEA,MAAM,EAAEE,OAAO,EAAmC,EAAQ;QACvE,IAAI,CAACH,gBAAgBC,SACjB;QAQJ,IAAIE,AAA2B,MAA3BA,QAAQ,OAAO,CAAC,MAAM,EACtB;QAGJ,MAAMC,UAAUD,QAAQ,OAAO,CAAC,GAAG,CAACE,CAAAA,QACzB;gBACH,KAAKA,MAAM,GAAG;gBACd,WAAWA,MAAM,SAAS;gBAC1B,WAAWA,MAAM,SAAS;gBAC1B,SAASA,MAAM,OAAO;gBAMtB,MAAMC,KAAK,KAAK,CAACD,MAAM,IAAI;YAC/B;QAGJE,eAAeN,OAAO,MAAM,EAAE;YAC1B,SAAS;YACT,WAAWA,OAAO,SAAS;YAC3B,KAAKA,OAAO,GAAG;YACf,YAAYE,QAAQ,UAAU;YAC9B,YAAYF,OAAO,UAAU;YAC7BG;YACA,OAAOD,QAAQ,KAAK;YACpB,SAASA,QAAQ,OAAO;YACxB,WAAWA,QAAQ,SAAS;QAChC;IACJ;AACJ;AAMO,MAAMI,iBAAiB,CAACC,QAA6BC;IACxDD,OAAO,UAAU,GAAG;QAAE,GAAGA,OAAO,UAAU;QAAEC;IAAM;AACtD;AAEO,MAAMC,2BAA2BC,qBAAqB;IACzD,aAAaC;IACb,gBAAgBV;IAChB,cAAc,EAAE;AACpB"}

package/features/debugger/__tests__/matchNamespace.test.d.ts

@@ -0,0 +1 @@
+export {};

package/features/debugger/__tests__/matchNamespace.test.js

@@ -0,0 +1,67 @@
+import { describe, expect, it } from "vitest";
+import { createNamespaceFilter, parseNamespaceHeader } from "../matchNamespace.js";
+describe("parseNamespaceHeader", ()=>{
+    it("should not start a session when the header is absent or empty", ()=>{
+        expect(parseNamespaceHeader(void 0)).toEqual([]);
+        expect(parseNamespaceHeader("")).toEqual([]);
+        expect(parseNamespaceHeader("   ")).toEqual([]);
+    });
+    it("should treat the truthy shorthands as capture-all", ()=>{
+        expect(parseNamespaceHeader("1")).toEqual([
+            "*"
+        ]);
+        expect(parseNamespaceHeader("true")).toEqual([
+            "*"
+        ]);
+        expect(parseNamespaceHeader("*")).toEqual([
+            "*"
+        ]);
+    });
+    it("should trim tokens, since duplicate headers arrive comma-joined with spaces", ()=>{
+        expect(parseNamespaceHeader("cms.os.*, fm.*")).toEqual([
+            "cms.os.*",
+            "fm.*"
+        ]);
+    });
+    it("should accept the array form produced by app.inject", ()=>{
+        expect(parseNamespaceHeader([
+            "cms.os.*",
+            "fm.*"
+        ])).toEqual([
+            "cms.os.*",
+            "fm.*"
+        ]);
+    });
+});
+describe("createNamespaceFilter", ()=>{
+    it("should match everything for the wildcard", ()=>{
+        const filter = createNamespaceFilter([
+            "*"
+        ]);
+        expect(filter.matches("cms.os.list")).toBe(true);
+        expect(filter.matches("core.anything")).toBe(true);
+    });
+    it("should match a prefix glob across dots", ()=>{
+        const filter = createNamespaceFilter([
+            "cms.*"
+        ]);
+        expect(filter.matches("cms.os.list")).toBe(true);
+        expect(filter.matches("fm.file.get")).toBe(false);
+    });
+    it("should exclude rather than invert on negation", ()=>{
+        const filter = createNamespaceFilter([
+            "*",
+            "!cms.os.*"
+        ]);
+        expect(filter.matches("cms.os.list")).toBe(false);
+        expect(filter.matches("fm.file.get")).toBe(true);
+    });
+    it("should require at least one positive match", ()=>{
+        const filter = createNamespaceFilter([
+            "!cms.os.*"
+        ]);
+        expect(filter.matches("fm.file.get")).toBe(false);
+    });
+});
+
+//# sourceMappingURL=matchNamespace.test.js.map

package/features/debugger/__tests__/matchNamespace.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/debugger/__tests__/matchNamespace.test.js","sources":["../../../../src/features/debugger/__tests__/matchNamespace.test.ts"],"sourcesContent":["import { describe, expect, it } from \"vitest\";\nimport { createNamespaceFilter, parseNamespaceHeader } from \"../matchNamespace.js\";\n\ndescribe(\"parseNamespaceHeader\", () => {\n    it(\"should not start a session when the header is absent or empty\", () => {\n        expect(parseNamespaceHeader(undefined)).toEqual([]);\n        expect(parseNamespaceHeader(\"\")).toEqual([]);\n        expect(parseNamespaceHeader(\"   \")).toEqual([]);\n    });\n\n    it(\"should treat the truthy shorthands as capture-all\", () => {\n        expect(parseNamespaceHeader(\"1\")).toEqual([\"*\"]);\n        expect(parseNamespaceHeader(\"true\")).toEqual([\"*\"]);\n        expect(parseNamespaceHeader(\"*\")).toEqual([\"*\"]);\n    });\n\n    it(\"should trim tokens, since duplicate headers arrive comma-joined with spaces\", () => {\n        expect(parseNamespaceHeader(\"cms.os.*, fm.*\")).toEqual([\"cms.os.*\", \"fm.*\"]);\n    });\n\n    it(\"should accept the array form produced by app.inject\", () => {\n        expect(parseNamespaceHeader([\"cms.os.*\", \"fm.*\"])).toEqual([\"cms.os.*\", \"fm.*\"]);\n    });\n});\n\ndescribe(\"createNamespaceFilter\", () => {\n    it(\"should match everything for the wildcard\", () => {\n        const filter = createNamespaceFilter([\"*\"]);\n\n        expect(filter.matches(\"cms.os.list\")).toBe(true);\n        expect(filter.matches(\"core.anything\")).toBe(true);\n    });\n\n    it(\"should match a prefix glob across dots\", () => {\n        const filter = createNamespaceFilter([\"cms.*\"]);\n\n        expect(filter.matches(\"cms.os.list\")).toBe(true);\n        expect(filter.matches(\"fm.file.get\")).toBe(false);\n    });\n\n    it(\"should exclude rather than invert on negation\", () => {\n        const filter = createNamespaceFilter([\"*\", \"!cms.os.*\"]);\n\n        expect(filter.matches(\"cms.os.list\")).toBe(false);\n        expect(filter.matches(\"fm.file.get\")).toBe(true);\n    });\n\n    it(\"should require at least one positive match\", () => {\n        const filter = createNamespaceFilter([\"!cms.os.*\"]);\n\n        expect(filter.matches(\"fm.file.get\")).toBe(false);\n    });\n});\n"],"names":["describe","it","expect","parseNamespaceHeader","undefined","filter","createNamespaceFilter"],"mappings":";;AAGAA,SAAS,wBAAwB;IAC7BC,GAAG,iEAAiE;QAChEC,OAAOC,qBAAqBC,SAAY,OAAO,CAAC,EAAE;QAClDF,OAAOC,qBAAqB,KAAK,OAAO,CAAC,EAAE;QAC3CD,OAAOC,qBAAqB,QAAQ,OAAO,CAAC,EAAE;IAClD;IAEAF,GAAG,qDAAqD;QACpDC,OAAOC,qBAAqB,MAAM,OAAO,CAAC;YAAC;SAAI;QAC/CD,OAAOC,qBAAqB,SAAS,OAAO,CAAC;YAAC;SAAI;QAClDD,OAAOC,qBAAqB,MAAM,OAAO,CAAC;YAAC;SAAI;IACnD;IAEAF,GAAG,+EAA+E;QAC9EC,OAAOC,qBAAqB,mBAAmB,OAAO,CAAC;YAAC;YAAY;SAAO;IAC/E;IAEAF,GAAG,uDAAuD;QACtDC,OAAOC,qBAAqB;YAAC;YAAY;SAAO,GAAG,OAAO,CAAC;YAAC;YAAY;SAAO;IACnF;AACJ;AAEAH,SAAS,yBAAyB;IAC9BC,GAAG,4CAA4C;QAC3C,MAAMI,SAASC,sBAAsB;YAAC;SAAI;QAE1CJ,OAAOG,OAAO,OAAO,CAAC,gBAAgB,IAAI,CAAC;QAC3CH,OAAOG,OAAO,OAAO,CAAC,kBAAkB,IAAI,CAAC;IACjD;IAEAJ,GAAG,0CAA0C;QACzC,MAAMI,SAASC,sBAAsB;YAAC;SAAQ;QAE9CJ,OAAOG,OAAO,OAAO,CAAC,gBAAgB,IAAI,CAAC;QAC3CH,OAAOG,OAAO,OAAO,CAAC,gBAAgB,IAAI,CAAC;IAC/C;IAEAJ,GAAG,iDAAiD;QAChD,MAAMI,SAASC,sBAAsB;YAAC;YAAK;SAAY;QAEvDJ,OAAOG,OAAO,OAAO,CAAC,gBAAgB,IAAI,CAAC;QAC3CH,OAAOG,OAAO,OAAO,CAAC,gBAAgB,IAAI,CAAC;IAC/C;IAEAJ,GAAG,8CAA8C;QAC7C,MAAMI,SAASC,sBAAsB;YAAC;SAAY;QAElDJ,OAAOG,OAAO,OAAO,CAAC,gBAAgB,IAAI,CAAC;IAC/C;AACJ"}

package/features/debugger/__tests__/serialize.test.d.ts

@@ -0,0 +1 @@
+export {};

package/features/debugger/__tests__/serialize.test.js

@@ -0,0 +1,220 @@
+import { describe, expect, it } from "vitest";
+import { serialize } from "../serialize.js";
+import { DEFAULT_LIMITS } from "../limits.js";
+const limits = (overrides = {})=>({
+        ...DEFAULT_LIMITS,
+        ...overrides
+    });
+const parse = (value, overrides = {})=>{
+    const result = serialize(value, limits(overrides));
+    return {
+        ...result,
+        parsed: JSON.parse(result.json)
+    };
+};
+describe("serialize", ()=>{
+    it("should always produce parseable JSON", ()=>{
+        const circular = {
+            name: "root"
+        };
+        circular.self = circular;
+        const { parsed } = parse(circular);
+        expect(parsed).toEqual({
+            name: "root",
+            self: "#[Circular]"
+        });
+    });
+    it("should not report siblings as circular", ()=>{
+        const shared = {
+            id: 1
+        };
+        const { parsed } = parse({
+            a: shared,
+            b: shared
+        });
+        expect(parsed).toEqual({
+            a: {
+                id: 1
+            },
+            b: {
+                id: 1
+            }
+        });
+    });
+    it("should serialize an Error, which JSON.stringify renders as an empty object", ()=>{
+        const error = new Error("Boom");
+        const { parsed } = parse({
+            error
+        });
+        expect(parsed.error.name).toBe("Error");
+        expect(parsed.error.message).toBe("Boom");
+        expect(typeof parsed.error.stack).toBe("string");
+    });
+    it("should serialize a BigInt, which JSON.stringify throws on", ()=>{
+        const { parsed } = parse({
+            value: BigInt(123)
+        });
+        expect(parsed).toEqual({
+            value: "123n"
+        });
+    });
+    it("should describe binary data without including its contents", ()=>{
+        const { parsed } = parse({
+            buffer: Buffer.from("hello world")
+        });
+        expect(parsed).toEqual({
+            buffer: "#[Buffer 11 bytes]"
+        });
+    });
+    it("should serialize Map and Set", ()=>{
+        const { parsed } = parse({
+            map: new Map([
+                [
+                    "a",
+                    1
+                ]
+            ]),
+            set: new Set([
+                1,
+                2
+            ])
+        });
+        expect(parsed.map).toEqual({
+            __type: "Map",
+            entries: [
+                [
+                    "a",
+                    1
+                ]
+            ]
+        });
+        expect(parsed.set).toEqual({
+            __type: "Set",
+            items: [
+                1,
+                2
+            ]
+        });
+    });
+    it("should drop an undefined property, so a logged payload matches what was sent", ()=>{
+        const { parsed } = parse({
+            kept: 1,
+            dropped: void 0
+        });
+        expect(parsed).toEqual({
+            kept: 1
+        });
+    });
+    it("should keep undefined array elements, where dropping would shift every later index", ()=>{
+        const { parsed } = parse({
+            items: [
+                1,
+                void 0,
+                3
+            ]
+        });
+        expect(parsed).toEqual({
+            items: [
+                1,
+                "#[Undefined value]",
+                3
+            ]
+        });
+    });
+    it("should not throw when a getter throws", ()=>{
+        const value = {
+            get exploding () {
+                throw new Error("Nope");
+            },
+            safe: 1
+        };
+        const { parsed } = parse(value);
+        expect(parsed.exploding).toBe("#[Throws: Nope]");
+        expect(parsed.safe).toBe(1);
+    });
+    it("should cap depth", ()=>{
+        const { parsed } = parse({
+            a: {
+                b: {
+                    c: {
+                        d: "deep"
+                    }
+                }
+            }
+        }, {
+            depth: 2
+        });
+        expect(parsed).toEqual({
+            a: {
+                b: "#[Depth limit]"
+            }
+        });
+    });
+    it("should cap string length and say how much was cut", ()=>{
+        const { parsed } = parse({
+            text: "x".repeat(20)
+        }, {
+            stringLength: 5
+        });
+        expect(parsed).toEqual({
+            text: "xxxxx…(15 more)"
+        });
+    });
+    it("should cap array length and say how much was cut", ()=>{
+        const { parsed } = parse({
+            items: [
+                1,
+                2,
+                3,
+                4,
+                5
+            ]
+        }, {
+            arrayLength: 2
+        });
+        expect(parsed).toEqual({
+            items: [
+                1,
+                2,
+                "…(3 more items)"
+            ]
+        });
+    });
+    it("should replace the payload wholesale when it exceeds the per-entry cap", ()=>{
+        const result = parse({
+            text: "x".repeat(5000)
+        }, {
+            entryBytes: 100,
+            stringLength: 100000
+        });
+        expect(result.truncated).toBe(true);
+        expect(result.parsed.truncated).toBe(true);
+        expect(result.parsed.originalBytes).toBeGreaterThan(100);
+        expect(result.bytes).toBeLessThanOrEqual(100);
+    });
+    it("should never invoke a custom toJSON, so it cannot be broken by one", ()=>{
+        const value = {
+            id: 1,
+            toJSON () {
+                throw new Error("Nope");
+            }
+        };
+        const { parsed } = parse({
+            value
+        });
+        expect(parsed.value.id).toBe(1);
+        expect(parsed.value.toJSON).toBe("#[Function: toJSON]");
+    });
+    it("should keep non-finite numbers readable instead of turning them into null", ()=>{
+        const { parsed } = parse({
+            a: 1 / 0,
+            b: NaN
+        });
+        expect(parsed).toEqual({
+            a: "Infinity",
+            b: "NaN"
+        });
+    });
+});
+
+//# sourceMappingURL=serialize.test.js.map