@livon/schema 0.27.0-rc.1

package/dist/context.d.ts

@@ -0,0 +1,101 @@
+import { AstBuilder, SchemaBuildContext, SchemaBuildContextInput, SchemaRequestContext, SchemaRequestContextInput, SchemaState, SchemaContext } from './types.js';
+export interface StateSnapshotRecord {
+    [key: string]: unknown;
+}
+export interface StateUpdater<T> {
+    (current: T | undefined): T;
+}
+export interface CreateBuilder {
+    (): AstBuilder;
+}
+export interface CreateState {
+    (): SchemaState;
+}
+/**
+ * createBuilder is part of the public LIVON API.
+ *
+ * @remarks
+ * Parameter and return types are defined in the TypeScript signature.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/context
+ *
+ * @example
+ * const result = createBuilder(undefined as never);
+ */
+export declare const createBuilder: CreateBuilder;
+/**
+ * createState is part of the public LIVON API.
+ *
+ * @remarks
+ * Parameter and return types are defined in the TypeScript signature.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/context
+ *
+ * @example
+ * const result = createState(undefined as never);
+ */
+export declare const createState: CreateState;
+export interface NormalizeBuildContext {
+    (input?: SchemaBuildContextInput): SchemaBuildContext;
+}
+/**
+ * normalizeBuildContext is part of the public LIVON API.
+ *
+ * @remarks
+ * Parameter and return types are defined in the TypeScript signature.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/context
+ *
+ * @example
+ * const result = normalizeBuildContext(undefined as never);
+ */
+export declare const normalizeBuildContext: NormalizeBuildContext;
+export interface IsNormalizedRequest {
+    (input: SchemaRequestContextInput): input is SchemaRequestContext;
+}
+/**
+ * isNormalizedRequest is part of the public LIVON API.
+ *
+ * @remarks
+ * Parameter and return types are defined in the TypeScript signature.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/context
+ *
+ * @example
+ * const result = isNormalizedRequest(undefined as never);
+ */
+export declare const isNormalizedRequest: (input: SchemaRequestContextInput) => input is SchemaRequestContext;
+export interface NormalizeRequestContext {
+    (input?: SchemaRequestContextInput): SchemaRequestContext;
+}
+/**
+ * normalizeRequestContext is part of the public LIVON API.
+ *
+ * @remarks
+ * Parameter and return types are defined in the TypeScript signature.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/context
+ *
+ * @example
+ * const result = normalizeRequestContext(undefined as never);
+ */
+export declare const normalizeRequestContext: NormalizeRequestContext;
+export interface CreateSchemaContextInput {
+    build?: SchemaBuildContextInput;
+    request?: SchemaRequestContextInput;
+}
+export interface CreateSchemaContext {
+    (input?: CreateSchemaContextInput): SchemaContext;
+}
+/**
+ * createSchemaContext is part of the public LIVON API.
+ *
+ * @remarks
+ * Parameter and return types are defined in the TypeScript signature.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/context
+ *
+ * @example
+ * const result = createSchemaContext(undefined as never);
+ */
+export declare const createSchemaContext: CreateSchemaContext;

package/dist/context.js

@@ -0,0 +1,76 @@
+const createBuilder = ()=>{
+    const nodes = [];
+    return {
+        add: (node)=>{
+            nodes.push(node);
+            return node;
+        },
+        getAll: ()=>nodes
+    };
+};
+const createState = ()=>{
+    const store = new Map();
+    return {
+        get: (key)=>store.get(key),
+        set: (key, value)=>{
+            store.set(key, value);
+        },
+        update: (key, updater)=>{
+            const next = updater(store.get(key));
+            store.set(key, next);
+        },
+        snapshot: ()=>Array.from(store.entries()).reduce((acc, [key, value])=>{
+                acc[key] = value;
+                return acc;
+            }, {})
+    };
+};
+const normalizeBuildContext = (input = {})=>({
+        buildId: input.buildId ?? `${Date.now()}-${Math.random().toString(16).slice(2)}`,
+        builder: input.builder ?? createBuilder(),
+        parentNode: input.parentNode,
+        schemaPath: input.schemaPath ?? [],
+        buildOptions: input.buildOptions ?? {}
+    });
+const isNormalizedRequest = (input)=>true === input.normalized;
+const normalizeRequestContext = (input = {})=>{
+    if (isNormalizedRequest(input)) return input;
+    return {
+        normalized: true,
+        requestId: input.requestId ?? `${Date.now()}-${Math.random().toString(16).slice(2)}`,
+        timestamp: input.timestamp ?? Date.now(),
+        correlationId: input.correlationId,
+        sourceId: input.sourceId,
+        userId: input.userId,
+        tenantId: input.tenantId,
+        metadata: input.metadata,
+        state: createState(),
+        publisher: input.publisher,
+        onPublishError: input.onPublishError,
+        logger: input.logger
+    };
+};
+const createSchemaContext = (input = {})=>{
+    let buildContext = input.build ? normalizeBuildContext(input.build) : void 0;
+    let requestContext = input.request ? normalizeRequestContext(input.request) : void 0;
+    const state = requestContext?.state ?? createState();
+    return {
+        getBuildContext: ()=>buildContext,
+        setBuildContext: (next)=>{
+            buildContext = next;
+        },
+        getRequestContext: ()=>requestContext,
+        get request () {
+            return requestContext;
+        },
+        setRequestContext: (next)=>{
+            requestContext = next ? normalizeRequestContext(next) : void 0;
+            if (requestContext && requestContext.state !== state) requestContext = {
+                ...requestContext,
+                state
+            };
+        },
+        state
+    };
+};
+export { createBuilder, createSchemaContext, createState, isNormalizedRequest, normalizeBuildContext, normalizeRequestContext };

package/dist/context.spec.cjs

@@ -0,0 +1,244 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const external_context_cjs_namespaceObject = require("./context.cjs");
+(0, external_vitest_namespaceObject.describe)('context utilities', ()=>{
+    let dateNowSpy;
+    let randomSpy;
+    let buildInput;
+    let requestInput;
+    (0, external_vitest_namespaceObject.beforeAll)(()=>{
+        dateNowSpy = external_vitest_namespaceObject.vi.spyOn(Date, 'now');
+        randomSpy = external_vitest_namespaceObject.vi.spyOn(Math, 'random');
+        buildInput = {};
+        requestInput = {};
+    });
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        dateNowSpy.mockReturnValue(1700000000000);
+        randomSpy.mockReturnValue(0.25);
+        buildInput = {};
+        requestInput = {};
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        external_vitest_namespaceObject.vi.clearAllMocks();
+        buildInput = {};
+        requestInput = {};
+    });
+    (0, external_vitest_namespaceObject.afterAll)(()=>{
+        dateNowSpy.mockRestore();
+        randomSpy.mockRestore();
+    });
+    (0, external_vitest_namespaceObject.describe)('createBuilder()', ()=>{
+        (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+            (0, external_vitest_namespaceObject.it)('should collect ast nodes when add is called', ()=>{
+                const builder = (0, external_context_cjs_namespaceObject.createBuilder)();
+                const node = {
+                    type: 'string',
+                    name: 'UserName'
+                };
+                const addedNode = builder.add(node);
+                const allNodes = builder.getAll();
+                (0, external_vitest_namespaceObject.expect)(addedNode).toBe(node);
+                (0, external_vitest_namespaceObject.expect)(allNodes).toEqual([
+                    node
+                ]);
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+            (0, external_vitest_namespaceObject.it)('should return empty list when no nodes are added', ()=>{
+                const builder = (0, external_context_cjs_namespaceObject.createBuilder)();
+                (0, external_vitest_namespaceObject.expect)(builder.getAll()).toEqual([]);
+            });
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('createState()', ()=>{
+        (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+            (0, external_vitest_namespaceObject.it)('should store and read value when set is called before get', ()=>{
+                const state = (0, external_context_cjs_namespaceObject.createState)();
+                state.set('userId', 'u-1');
+                (0, external_vitest_namespaceObject.expect)(state.get('userId')).toBe('u-1');
+            });
+            (0, external_vitest_namespaceObject.it)('should update value when update is called', ()=>{
+                const state = (0, external_context_cjs_namespaceObject.createState)();
+                state.set('counter', 1);
+                state.update('counter', (current)=>(current ?? 0) + 1);
+                (0, external_vitest_namespaceObject.expect)(state.get('counter')).toBe(2);
+            });
+            (0, external_vitest_namespaceObject.it)('should include all entries when snapshot is called', ()=>{
+                const state = (0, external_context_cjs_namespaceObject.createState)();
+                state.set('tenantId', 't-1');
+                state.set('isAdmin', true);
+                (0, external_vitest_namespaceObject.expect)(state.snapshot()).toEqual({
+                    tenantId: 't-1',
+                    isAdmin: true
+                });
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+            (0, external_vitest_namespaceObject.it)('should provide undefined when key was never set', ()=>{
+                const state = (0, external_context_cjs_namespaceObject.createState)();
+                (0, external_vitest_namespaceObject.expect)(state.get('missing')).toBeUndefined();
+            });
+            (0, external_vitest_namespaceObject.it)('should pass undefined to updater when value is missing', ()=>{
+                const state = (0, external_context_cjs_namespaceObject.createState)();
+                const updater = external_vitest_namespaceObject.vi.fn((current)=>(current ?? 0) + 10);
+                state.update('counter', updater);
+                (0, external_vitest_namespaceObject.expect)(updater).toHaveBeenCalledWith(void 0);
+                (0, external_vitest_namespaceObject.expect)(state.get('counter')).toBe(10);
+            });
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('normalizeBuildContext()', ()=>{
+        (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+            (0, external_vitest_namespaceObject.it)('should create defaults when input is missing', ()=>{
+                const context = (0, external_context_cjs_namespaceObject.normalizeBuildContext)();
+                (0, external_vitest_namespaceObject.expect)(context.buildId).toBe('1700000000000-4');
+                (0, external_vitest_namespaceObject.expect)(context.schemaPath).toEqual([]);
+                (0, external_vitest_namespaceObject.expect)(context.buildOptions).toEqual({});
+                (0, external_vitest_namespaceObject.expect)(context.builder.getAll()).toEqual([]);
+            });
+            (0, external_vitest_namespaceObject.it)('should keep provided values when input provides them', ()=>{
+                const builder = (0, external_context_cjs_namespaceObject.createBuilder)();
+                buildInput = {
+                    buildId: 'custom-build',
+                    builder,
+                    schemaPath: [
+                        'root'
+                    ],
+                    buildOptions: {
+                        explain: true
+                    }
+                };
+                const context = (0, external_context_cjs_namespaceObject.normalizeBuildContext)(buildInput);
+                (0, external_vitest_namespaceObject.expect)(context.buildId).toBe('custom-build');
+                (0, external_vitest_namespaceObject.expect)(context.builder).toBe(builder);
+                (0, external_vitest_namespaceObject.expect)(context.schemaPath).toEqual([
+                    'root'
+                ]);
+                (0, external_vitest_namespaceObject.expect)(context.buildOptions).toEqual({
+                    explain: true
+                });
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+            (0, external_vitest_namespaceObject.it)('should keep parent node undefined when parent node is omitted', ()=>{
+                const context = (0, external_context_cjs_namespaceObject.normalizeBuildContext)();
+                (0, external_vitest_namespaceObject.expect)(context.parentNode).toBeUndefined();
+            });
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('isNormalizedRequest()', ()=>{
+        (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+            (0, external_vitest_namespaceObject.it)('should return true when normalized flag is true', ()=>{
+                const input = {
+                    normalized: true
+                };
+                (0, external_vitest_namespaceObject.expect)((0, external_context_cjs_namespaceObject.isNormalizedRequest)(input)).toBe(true);
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+            (0, external_vitest_namespaceObject.it)('should return false when normalized flag is missing', ()=>{
+                (0, external_vitest_namespaceObject.expect)((0, external_context_cjs_namespaceObject.isNormalizedRequest)({})).toBe(false);
+            });
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('normalizeRequestContext()', ()=>{
+        (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+            (0, external_vitest_namespaceObject.it)('should create normalized context when input is plain request input', ()=>{
+                requestInput = {
+                    correlationId: 'corr-1',
+                    metadata: {
+                        source: 'test'
+                    }
+                };
+                const context = (0, external_context_cjs_namespaceObject.normalizeRequestContext)(requestInput);
+                (0, external_vitest_namespaceObject.expect)(context.normalized).toBe(true);
+                (0, external_vitest_namespaceObject.expect)(context.requestId).toBe('1700000000000-4');
+                (0, external_vitest_namespaceObject.expect)(context.timestamp).toBe(1700000000000);
+                (0, external_vitest_namespaceObject.expect)(context.correlationId).toBe('corr-1');
+                (0, external_vitest_namespaceObject.expect)(context.metadata).toEqual({
+                    source: 'test'
+                });
+            });
+            (0, external_vitest_namespaceObject.it)('should return same instance when request is already normalized', ()=>{
+                const state = (0, external_context_cjs_namespaceObject.createState)();
+                const normalized = (0, external_context_cjs_namespaceObject.normalizeRequestContext)({
+                    normalized: true,
+                    requestId: 'already-normalized',
+                    timestamp: 123,
+                    state
+                });
+                const result = (0, external_context_cjs_namespaceObject.normalizeRequestContext)(normalized);
+                (0, external_vitest_namespaceObject.expect)(result).toBe(normalized);
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+            (0, external_vitest_namespaceObject.it)('should create empty metadata when metadata is not provided', ()=>{
+                const context = (0, external_context_cjs_namespaceObject.normalizeRequestContext)({});
+                (0, external_vitest_namespaceObject.expect)(context.metadata).toBeUndefined();
+            });
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('createSchemaContext()', ()=>{
+        (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+            (0, external_vitest_namespaceObject.it)('should expose normalized build and request contexts when input is provided', ()=>{
+                const context = (0, external_context_cjs_namespaceObject.createSchemaContext)({
+                    build: {
+                        buildId: 'build-1'
+                    },
+                    request: {
+                        requestId: 'req-1',
+                        timestamp: 11,
+                        normalized: true,
+                        state: (0, external_context_cjs_namespaceObject.createState)()
+                    }
+                });
+                (0, external_vitest_namespaceObject.expect)(context.getBuildContext()?.buildId).toBe('build-1');
+                (0, external_vitest_namespaceObject.expect)(context.getRequestContext()?.requestId).toBe('req-1');
+            });
+            (0, external_vitest_namespaceObject.it)('should keep shared state when replacing request context with different state instance', ()=>{
+                const initialState = (0, external_context_cjs_namespaceObject.createState)();
+                const nextState = (0, external_context_cjs_namespaceObject.createState)();
+                const context = (0, external_context_cjs_namespaceObject.createSchemaContext)({
+                    request: {
+                        normalized: true,
+                        requestId: 'req-a',
+                        timestamp: 1,
+                        state: initialState
+                    }
+                });
+                context.setRequestContext({
+                    normalized: true,
+                    requestId: 'req-b',
+                    timestamp: 2,
+                    state: nextState
+                });
+                (0, external_vitest_namespaceObject.expect)(context.getRequestContext()?.requestId).toBe('req-b');
+                (0, external_vitest_namespaceObject.expect)(context.getRequestContext()?.state).toBe(initialState);
+            });
+            (0, external_vitest_namespaceObject.it)('should update build context when setBuildContext is called', ()=>{
+                const context = (0, external_context_cjs_namespaceObject.createSchemaContext)();
+                context.setBuildContext((0, external_context_cjs_namespaceObject.normalizeBuildContext)({
+                    buildId: 'updated-build'
+                }));
+                (0, external_vitest_namespaceObject.expect)(context.getBuildContext()?.buildId).toBe('updated-build');
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+            (0, external_vitest_namespaceObject.it)('should clear request context when setRequestContext receives undefined', ()=>{
+                const context = (0, external_context_cjs_namespaceObject.createSchemaContext)({
+                    request: {
+                        requestId: 'req-1',
+                        timestamp: 11
+                    }
+                });
+                context.setRequestContext(void 0);
+                (0, external_vitest_namespaceObject.expect)(context.getRequestContext()).toBeUndefined();
+            });
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/context.spec.d.ts

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

package/dist/context.spec.js

@@ -0,0 +1,238 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { createBuilder, createSchemaContext, createState, isNormalizedRequest, normalizeBuildContext, normalizeRequestContext } from "./context.js";
+describe('context utilities', ()=>{
+    let dateNowSpy;
+    let randomSpy;
+    let buildInput;
+    let requestInput;
+    beforeAll(()=>{
+        dateNowSpy = vi.spyOn(Date, 'now');
+        randomSpy = vi.spyOn(Math, 'random');
+        buildInput = {};
+        requestInput = {};
+    });
+    beforeEach(()=>{
+        dateNowSpy.mockReturnValue(1700000000000);
+        randomSpy.mockReturnValue(0.25);
+        buildInput = {};
+        requestInput = {};
+    });
+    afterEach(()=>{
+        vi.clearAllMocks();
+        buildInput = {};
+        requestInput = {};
+    });
+    afterAll(()=>{
+        dateNowSpy.mockRestore();
+        randomSpy.mockRestore();
+    });
+    describe('createBuilder()', ()=>{
+        describe('happy', ()=>{
+            it('should collect ast nodes when add is called', ()=>{
+                const builder = createBuilder();
+                const node = {
+                    type: 'string',
+                    name: 'UserName'
+                };
+                const addedNode = builder.add(node);
+                const allNodes = builder.getAll();
+                expect(addedNode).toBe(node);
+                expect(allNodes).toEqual([
+                    node
+                ]);
+            });
+        });
+        describe('sad', ()=>{
+            it('should return empty list when no nodes are added', ()=>{
+                const builder = createBuilder();
+                expect(builder.getAll()).toEqual([]);
+            });
+        });
+    });
+    describe('createState()', ()=>{
+        describe('happy', ()=>{
+            it('should store and read value when set is called before get', ()=>{
+                const state = createState();
+                state.set('userId', 'u-1');
+                expect(state.get('userId')).toBe('u-1');
+            });
+            it('should update value when update is called', ()=>{
+                const state = createState();
+                state.set('counter', 1);
+                state.update('counter', (current)=>(current ?? 0) + 1);
+                expect(state.get('counter')).toBe(2);
+            });
+            it('should include all entries when snapshot is called', ()=>{
+                const state = createState();
+                state.set('tenantId', 't-1');
+                state.set('isAdmin', true);
+                expect(state.snapshot()).toEqual({
+                    tenantId: 't-1',
+                    isAdmin: true
+                });
+            });
+        });
+        describe('sad', ()=>{
+            it('should provide undefined when key was never set', ()=>{
+                const state = createState();
+                expect(state.get('missing')).toBeUndefined();
+            });
+            it('should pass undefined to updater when value is missing', ()=>{
+                const state = createState();
+                const updater = vi.fn((current)=>(current ?? 0) + 10);
+                state.update('counter', updater);
+                expect(updater).toHaveBeenCalledWith(void 0);
+                expect(state.get('counter')).toBe(10);
+            });
+        });
+    });
+    describe('normalizeBuildContext()', ()=>{
+        describe('happy', ()=>{
+            it('should create defaults when input is missing', ()=>{
+                const context = normalizeBuildContext();
+                expect(context.buildId).toBe('1700000000000-4');
+                expect(context.schemaPath).toEqual([]);
+                expect(context.buildOptions).toEqual({});
+                expect(context.builder.getAll()).toEqual([]);
+            });
+            it('should keep provided values when input provides them', ()=>{
+                const builder = createBuilder();
+                buildInput = {
+                    buildId: 'custom-build',
+                    builder,
+                    schemaPath: [
+                        'root'
+                    ],
+                    buildOptions: {
+                        explain: true
+                    }
+                };
+                const context = normalizeBuildContext(buildInput);
+                expect(context.buildId).toBe('custom-build');
+                expect(context.builder).toBe(builder);
+                expect(context.schemaPath).toEqual([
+                    'root'
+                ]);
+                expect(context.buildOptions).toEqual({
+                    explain: true
+                });
+            });
+        });
+        describe('sad', ()=>{
+            it('should keep parent node undefined when parent node is omitted', ()=>{
+                const context = normalizeBuildContext();
+                expect(context.parentNode).toBeUndefined();
+            });
+        });
+    });
+    describe('isNormalizedRequest()', ()=>{
+        describe('happy', ()=>{
+            it('should return true when normalized flag is true', ()=>{
+                const input = {
+                    normalized: true
+                };
+                expect(isNormalizedRequest(input)).toBe(true);
+            });
+        });
+        describe('sad', ()=>{
+            it('should return false when normalized flag is missing', ()=>{
+                expect(isNormalizedRequest({})).toBe(false);
+            });
+        });
+    });
+    describe('normalizeRequestContext()', ()=>{
+        describe('happy', ()=>{
+            it('should create normalized context when input is plain request input', ()=>{
+                requestInput = {
+                    correlationId: 'corr-1',
+                    metadata: {
+                        source: 'test'
+                    }
+                };
+                const context = normalizeRequestContext(requestInput);
+                expect(context.normalized).toBe(true);
+                expect(context.requestId).toBe('1700000000000-4');
+                expect(context.timestamp).toBe(1700000000000);
+                expect(context.correlationId).toBe('corr-1');
+                expect(context.metadata).toEqual({
+                    source: 'test'
+                });
+            });
+            it('should return same instance when request is already normalized', ()=>{
+                const state = createState();
+                const normalized = normalizeRequestContext({
+                    normalized: true,
+                    requestId: 'already-normalized',
+                    timestamp: 123,
+                    state
+                });
+                const result = normalizeRequestContext(normalized);
+                expect(result).toBe(normalized);
+            });
+        });
+        describe('sad', ()=>{
+            it('should create empty metadata when metadata is not provided', ()=>{
+                const context = normalizeRequestContext({});
+                expect(context.metadata).toBeUndefined();
+            });
+        });
+    });
+    describe('createSchemaContext()', ()=>{
+        describe('happy', ()=>{
+            it('should expose normalized build and request contexts when input is provided', ()=>{
+                const context = createSchemaContext({
+                    build: {
+                        buildId: 'build-1'
+                    },
+                    request: {
+                        requestId: 'req-1',
+                        timestamp: 11,
+                        normalized: true,
+                        state: createState()
+                    }
+                });
+                expect(context.getBuildContext()?.buildId).toBe('build-1');
+                expect(context.getRequestContext()?.requestId).toBe('req-1');
+            });
+            it('should keep shared state when replacing request context with different state instance', ()=>{
+                const initialState = createState();
+                const nextState = createState();
+                const context = createSchemaContext({
+                    request: {
+                        normalized: true,
+                        requestId: 'req-a',
+                        timestamp: 1,
+                        state: initialState
+                    }
+                });
+                context.setRequestContext({
+                    normalized: true,
+                    requestId: 'req-b',
+                    timestamp: 2,
+                    state: nextState
+                });
+                expect(context.getRequestContext()?.requestId).toBe('req-b');
+                expect(context.getRequestContext()?.state).toBe(initialState);
+            });
+            it('should update build context when setBuildContext is called', ()=>{
+                const context = createSchemaContext();
+                context.setBuildContext(normalizeBuildContext({
+                    buildId: 'updated-build'
+                }));
+                expect(context.getBuildContext()?.buildId).toBe('updated-build');
+            });
+        });
+        describe('sad', ()=>{
+            it('should clear request context when setRequestContext receives undefined', ()=>{
+                const context = createSchemaContext({
+                    request: {
+                        requestId: 'req-1',
+                        timestamp: 11
+                    }
+                });
+                context.setRequestContext(void 0);
+                expect(context.getRequestContext()).toBeUndefined();
+            });
+        });
+    });
+});