@nlabs/reaktor 0.10.2 → 0.10.6

package/lib/utils/testUtils.js

@@ -1,2 +1,292 @@
-import{jest as t}from"@jest/globals";const y=(e={})=>{const r={userAccess:1,userId:"user1",username:"testuser"},n=e.session||{},s={databaseName:e.databaseName??"test",...e};return delete s.session,s.session={userAccess:n.userAccess!==void 0?n.userAccess:r.userAccess,userId:n.userId!==void 0?n.userId:r.userId,username:n.username!==void 0?n.username:r.username},s},x=(e="test")=>({fieldName:e,fieldNodes:[],fragments:{},operation:{},parentType:{},path:{key:e,prev:void 0,typename:"Test"},returnType:{},rootValue:{},schema:{},variableValues:{}}),A=async(e,r)=>{const n=Object.entries(r).reduce((s,[a,c])=>(s[a]=t.fn().mockImplementation(c),s),{});await t.isolateModulesAsync(async()=>{t.unstable_mockModule(e,()=>({__esModule:!0,...n,default:n}))})},I=async(e,r)=>{const n={__esModule:!0,[r]:{getField:t.fn(()=>({resolve:t.fn()})),getFields:t.fn(()=>({}))},default:{[r]:{getField:t.fn(()=>({resolve:t.fn()})),getFields:t.fn(()=>({}))}}};await t.isolateModulesAsync(async()=>{t.unstable_mockModule(e,()=>n)})},h=(e,r,n)=>{describe(`${e} Queries`,()=>{let s;const a=y();beforeAll(()=>{s={}}),n.forEach(({name:c,actionName:l,args:o,expectedCall:u,mockReturnValue:p,errorCase:d=!1})=>{it(`should call ${l} action with correct parameters`,async()=>{const i=t.fn().mockImplementation(()=>Promise.resolve(p));s[l]=i;const m=await i(a,o);expect(i).toHaveBeenCalledWith(a,u(a,o)),expect(m).toEqual(p)}),d&&it(`should handle ${l} when no data found`,async()=>{const i=t.fn().mockImplementation(()=>Promise.resolve(null));s[l]=i;const m=await i(a,o);expect(i).toHaveBeenCalledWith(a,u(a,o)),expect(m).toBeNull()})})})},M=(e,r,n)=>{describe(`${e} Mutations`,()=>{let s;beforeAll(()=>{s={}}),n.forEach(({actionName:a,args:c,expectedCall:l,mockReturnValue:o,requiresAuth:u=!1,authUserId:p})=>{it(`should call ${a} action with correct parameters`,async()=>{const d=y();u&&p&&(d.session.userId=p);const i=t.fn().mockImplementation(()=>Promise.resolve(o));s[a]=i;const m=await i(d,c);expect(i).toHaveBeenCalledWith(d,l(d,c)),expect(m).toEqual(o)})})})},b=(e,r,n,s,a)=>{describe(`${e} Integration`,()=>{let c;beforeAll(()=>{c={}}),a.forEach(({name:l,actionName:o,args:u,expectedCall:p,successReturnValue:d,errorReturnValue:i,testErrorCase:m})=>{describe(l,()=>{it(`should return data when ${o} succeeds`,async()=>{const g=y(),f=t.fn().mockImplementation(()=>Promise.resolve(d));c[o]=f;const T=await f(g,u);expect(f).toHaveBeenCalledWith(g,p(g,u)),expect(T).toEqual(d||{})}),m&&it(`should handle ${o} when no data found`,async()=>{const g=y(),f=t.fn().mockImplementation(()=>Promise.resolve(i));c[o]=f;const T=await f(g,u);expect(f).toHaveBeenCalledWith(g,p(g,u)),expect(T).toEqual(i)})})})})},v=(e={})=>({email:"test@example.com",firstName:"Test",lastName:"User",userId:"user1",username:"testuser",...e}),R=(e={})=>({content:"Test post content",createdAt:new Date().toISOString(),postId:"post1",userId:"user1",...e}),w=(e={})=>({content:"Test message",conversationId:"conv1",createdAt:new Date().toISOString(),messageId:"msg1",userId:"user1",...e}),C=(e={})=>({createdAt:new Date().toISOString(),postId:"post1",reactionId:"react1",type:"like",userId:"user1",...e}),E=(e={})=>({description:"Test tag description",name:"test-tag",tagId:"tag1",...e}),S=async()=>{const e={__esModule:!0,useDb:t.fn(),getLimit:t.fn(),getDocId:t.fn(),sortIds:t.fn(),getGqlFields:t.fn(),default:{useDb:t.fn(),getLimit:t.fn(),getDocId:t.fn(),sortIds:t.fn(),getGqlFields:t.fn()}};await t.isolateModulesAsync(async()=>{t.unstable_mockModule("./arangodbUtils.js",()=>e)})},V=()=>{t.clearAllMocks()},q=(e,r,n)=>{describe(`${e} actions`,()=>{let s;beforeAll(async()=>{s=await import(r)}),n.forEach(({name:a,actionName:c,args:l,mockQuery:o,expectedResult:u})=>{it(`should execute ${c}`,async()=>{const p=y(),d=t.fn().mockReturnValue({query:o}),i=t.requireActual("./arangodbUtils.js");t.doMock("./arangodbUtils.js",()=>({useDb:d,...i}));const m=await s[c](p,l);expect(m).toEqual(u)})})})},O=(e,r,n)=>{describe(e,()=>{let s;beforeAll(async()=>{s=await import(r)}),n.forEach(({name:a,input:c,expectedOutput:l})=>{it(`should ${a}`,()=>{const o=s.parseTag(c);expect(o).toEqual(l)})})})},P=(e,r,n)=>{describe(e,()=>{let s;beforeAll(async()=>{s=await import(r)}),n.forEach(({name:a,input:c,expectedOutput:l})=>{it(`should ${a}`,()=>{let o;if(s.logInfo)o=s.logInfo(c);else if(s.removeEmptyKeys)o=s.removeEmptyKeys(c);else throw new Error(`No suitable function found in ${r}`);expect(o).toEqual(l)})})})};export{V as clearAllMocks,q as createActionTestSuite,O as createAdapterTestSuite,b as createIntegrationTestSuite,y as createMockContext,w as createMockMessage,R as createMockPost,C as createMockReaction,x as createMockResolveInfo,E as createMockTag,v as createMockUser,M as createMutationTestSuite,h as createQueryTestSuite,P as createUtilsTestSuite,A as mockActionsModule,I as mockObjectType,S as setupCommonMocks};
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/utils/testUtils.ts"],
  "sourcesContent": ["/**\n * Copyright (c) 2025-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {jest} from '@jest/globals';\nimport type {GraphQLResolveInfo} from 'graphql';\n\n\nimport type {ApiContext} from '../types/auth.types.js';\n\n// Define proper types for test utilities\ntype MockOverrides = Partial<Record<string, unknown>>;\ntype TestContext = Partial<ApiContext> & {session?: Partial<{userId: string; username: string; userAccess: number}>};\ntype TestArgs = Record<string, unknown>;\ntype TestReturnValue = unknown;\n\nexport const createMockContext = (overrides: MockOverrides = {}): ApiContext => {\n  const defaultSession = {\n    userAccess: 1,\n    userId: 'user1',\n    username: 'testuser'\n  };\n  const overrideSession: Partial<typeof defaultSession> = overrides.session || {};\n  const context: TestContext = {\n    databaseName: (overrides.databaseName as string) ?? 'test',\n    ...overrides\n  };\n  delete context.session;\n  context.session = {\n    userAccess: overrideSession.userAccess !== undefined ? overrideSession.userAccess : defaultSession.userAccess,\n    userId: overrideSession.userId !== undefined ? overrideSession.userId : defaultSession.userId,\n    username: overrideSession.username !== undefined ? overrideSession.username : defaultSession.username\n  };\n  return context as ApiContext;\n};\n\n// Common mock resolve info for GraphQL resolvers\nexport const createMockResolveInfo = (fieldName: string = 'test'): GraphQLResolveInfo => {\n  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n  const operation = {} as GraphQLResolveInfo['operation'];\n  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n  const parentType = {} as GraphQLResolveInfo['parentType'];\n  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n  const returnType = {} as GraphQLResolveInfo['returnType'];\n  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n  const schema = {} as GraphQLResolveInfo['schema'];\n\n  return {\n    fieldName,\n    fieldNodes: [],\n    fragments: {},\n    operation,\n    parentType,\n    path: {key: fieldName, prev: undefined, typename: 'Test'},\n    returnType,\n    rootValue: {},\n    schema,\n    variableValues: {}\n  };\n};\n\n// Utility to mock actions module\nexport const mockActionsModule = async (modulePath: string, mockActions: Record<string, jest.Mock>) => {\n  const mocks = Object.entries(mockActions).reduce((acc, [key, value]) => {\n    acc[key] = jest.fn().mockImplementation(value);\n    return acc;\n  }, {} as Record<string, jest.Mock>);\n\n  await jest.isolateModulesAsync(async () => {\n    jest.unstable_mockModule(modulePath, () => ({\n      __esModule: true,\n      ...mocks,\n      default: mocks\n    }));\n  });\n};\n\n// Utility to mock object types\nexport const mockObjectType = async (modulePath: string, typeName: string) => {\n  const mock = {\n    __esModule: true,\n    [typeName]: {\n      getField: jest.fn(() => ({resolve: jest.fn()})),\n      getFields: jest.fn(() => ({}))\n    },\n    default: {\n      [typeName]: {\n        getField: jest.fn(() => ({resolve: jest.fn()})),\n        getFields: jest.fn(() => ({}))\n      }\n    }\n  };\n  await jest.isolateModulesAsync(async () => {\n    jest.unstable_mockModule(modulePath, () => mock);\n  });\n};\n\n// Utility to create a test suite for query resolvers\nexport const createQueryTestSuite = (\n  name: string,\n  actionsPath: string,\n  testCases: Array<{\n    name: string;\n    actionName: string;\n    args: TestArgs;\n    expectedCall: (context: TestContext, args: TestArgs) => TestArgs;\n    mockReturnValue: TestReturnValue;\n    errorCase?: boolean;\n  }>\n) => {\n  describe(`${name} Queries`, () => {\n    let actions: any;\n    const mockContext = createMockContext();\n\n    beforeAll(() => {\n      actions = {};\n    });\n\n    testCases.forEach(({name: testName, actionName, args, expectedCall, mockReturnValue, errorCase = false}) => {\n      it(`should call ${actionName} action with correct parameters`, async () => {\n        const mockFn = jest.fn().mockImplementation(() => Promise.resolve(mockReturnValue));\n        actions[actionName] = mockFn;\n\n        const result = await mockFn(mockContext, args);\n        expect(mockFn).toHaveBeenCalledWith(mockContext, expectedCall(mockContext, args));\n        expect(result).toEqual(mockReturnValue);\n      });\n\n      if(errorCase) {\n        it(`should handle ${actionName} when no data found`, async () => {\n          const mockFn = jest.fn().mockImplementation(() => Promise.resolve(null));\n          actions[actionName] = mockFn;\n\n          const result = await mockFn(mockContext, args);\n          expect(mockFn).toHaveBeenCalledWith(mockContext, expectedCall(mockContext, args));\n          expect(result).toBeNull();\n        });\n      }\n    });\n  });\n};\n\n// Utility to create a test suite for mutation resolvers\nexport const createMutationTestSuite = (\n  name: string,\n  actionsPath: string,\n  testCases: Array<{\n    name: string;\n    actionName: string;\n    args: TestArgs;\n    expectedCall: (context: TestContext, args: TestArgs) => TestArgs;\n    mockReturnValue: TestReturnValue;\n    requiresAuth?: boolean;\n    authUserId?: string;\n  }>\n) => {\n  describe(`${name} Mutations`, () => {\n    let actions: any;\n\n    beforeAll(() => {\n      actions = {};\n    });\n\n    testCases.forEach(({\n      actionName,\n      args,\n      expectedCall,\n      mockReturnValue,\n      requiresAuth = false,\n      authUserId\n    }) => {\n      it(`should call ${actionName} action with correct parameters`, async () => {\n        const mockContext = createMockContext();\n        if(requiresAuth && authUserId) {\n          (mockContext.session as {userId: string}).userId = authUserId;\n        }\n\n        const mockFn = jest.fn().mockImplementation(() => Promise.resolve(mockReturnValue));\n        actions[actionName] = mockFn;\n\n        const result = await mockFn(mockContext, args);\n        expect(mockFn).toHaveBeenCalledWith(mockContext, expectedCall(mockContext, args));\n        expect(result).toEqual(mockReturnValue);\n      });\n    });\n  });\n};\n\n// Utility to create integration test suite\nexport const createIntegrationTestSuite = (\n  name: string,\n  actionsPath: string,\n  objectTypePath: string,\n  typeName: string,\n  testCases: Array<{\n    name: string;\n    actionName: string;\n    args: TestArgs;\n    expectedCall: (context: TestContext, args: TestArgs) => TestArgs;\n    successReturnValue: TestReturnValue;\n    errorReturnValue: TestReturnValue;\n    testErrorCase: boolean;\n  }>\n) => {\n  describe(`${name} Integration`, () => {\n    let actions: any;\n\n    beforeAll(() => {\n      actions = {};\n    });\n\n    testCases.forEach(({\n      name: testName,\n      actionName,\n      args,\n      expectedCall,\n      successReturnValue,\n      errorReturnValue,\n      testErrorCase\n    }) => {\n      describe(testName, () => {\n        it(`should return data when ${actionName} succeeds`, async () => {\n          const mockContext = createMockContext();\n          const mockFn = jest.fn().mockImplementation(() => Promise.resolve(successReturnValue));\n          actions[actionName] = mockFn;\n\n          const result = await mockFn(mockContext, args);\n\n          expect(mockFn).toHaveBeenCalledWith(mockContext, expectedCall(mockContext, args));\n          expect(result).toEqual(successReturnValue || {});\n        });\n\n        if(testErrorCase) {\n          it(`should handle ${actionName} when no data found`, async () => {\n            const mockContext = createMockContext();\n            const mockFn = jest.fn().mockImplementation(() => Promise.resolve(errorReturnValue));\n            actions[actionName] = mockFn;\n\n            const result = await mockFn(mockContext, args);\n\n            expect(mockFn).toHaveBeenCalledWith(mockContext, expectedCall(mockContext, args));\n            expect(result).toEqual(errorReturnValue);\n          });\n        }\n      });\n    });\n  });\n};\n\n// Common mock data generators\nexport const createMockUser = (overrides: MockOverrides = {}) => ({\n  email: 'test@example.com',\n  firstName: 'Test',\n  lastName: 'User',\n  userId: 'user1',\n  username: 'testuser',\n  ...overrides\n});\n\nexport const createMockPost = (overrides: MockOverrides = {}) => ({\n  content: 'Test post content',\n  createdAt: new Date().toISOString(),\n  postId: 'post1',\n  userId: 'user1',\n  ...overrides\n});\n\nexport const createMockMessage = (overrides: MockOverrides = {}) => ({\n  content: 'Test message',\n  conversationId: 'conv1',\n  createdAt: new Date().toISOString(),\n  messageId: 'msg1',\n  userId: 'user1',\n  ...overrides\n});\n\nexport const createMockReaction = (overrides: MockOverrides = {}) => ({\n  createdAt: new Date().toISOString(),\n  postId: 'post1',\n  reactionId: 'react1',\n  type: 'like',\n  userId: 'user1',\n  ...overrides\n});\n\nexport const createMockTag = (overrides: MockOverrides = {}) => ({\n  description: 'Test tag description',\n  name: 'test-tag',\n  tagId: 'tag1',\n  ...overrides\n});\n\n// Utility to set up common mocks\nexport const setupCommonMocks = async () => {\n  const mock = {\n    __esModule: true,\n    useDb: jest.fn(),\n    getLimit: jest.fn(),\n    getDocId: jest.fn(),\n    sortIds: jest.fn(),\n    getGqlFields: jest.fn(),\n    default: {\n      useDb: jest.fn(),\n      getLimit: jest.fn(),\n      getDocId: jest.fn(),\n      sortIds: jest.fn(),\n      getGqlFields: jest.fn()\n    }\n  };\n  await jest.isolateModulesAsync(async () => {\n    jest.unstable_mockModule('./arangodbUtils.js', () => mock);\n  });\n};\n\n// Utility to clear all mocks\nexport const clearAllMocks = () => {\n  jest.clearAllMocks();\n};\n\n// Utility to create a test suite for action functions\nexport const createActionTestSuite = (\n  name: string,\n  actionsPath: string,\n  testCases: Array<{\n    name: string;\n    actionName: string;\n    args: TestArgs;\n    mockQuery: jest.Mock;\n    expectedResult: TestReturnValue;\n  }>\n) => {\n  describe(`${name} actions`, () => {\n    let actions: any;\n\n    beforeAll(async () => {\n      actions = await import(actionsPath);\n    });\n\n    testCases.forEach(({name: testName, actionName, args, mockQuery, expectedResult}) => {\n      it(`should execute ${actionName}`, async () => {\n        const mockContext = createMockContext();\n        const mockDb = jest.fn().mockReturnValue({\n          query: mockQuery\n        });\n        const actual = jest.requireActual('./arangodbUtils.js') as Record<string, unknown>;\n        jest.doMock('./arangodbUtils.js', () => ({\n          useDb: mockDb,\n          ...actual\n        }));\n\n        const result = await (actions[actionName] as jest.Mock)(mockContext, args);\n        expect(result).toEqual(expectedResult);\n      });\n    });\n  });\n};\n\nexport const createAdapterTestSuite = (\n  name: string,\n  adapterPath: string,\n  testCases: any[]\n) => {\n  describe(name, () => {\n    let adapter: any;\n\n    beforeAll(async () => {\n      adapter = await import(adapterPath);\n    });\n\n    testCases.forEach(({name: testName, input, expectedOutput}) => {\n      it(`should ${testName}`, () => {\n        const result = (adapter as {parseTag: (input: TestArgs) => TestReturnValue}).parseTag(input);\n        expect(result).toEqual(expectedOutput);\n      });\n    });\n  });\n};\n\nexport const createUtilsTestSuite = (\n  name: string,\n  utilsPath: string,\n  testCases: Array<{\n    name: string;\n    input: TestArgs;\n    expectedOutput: TestReturnValue;\n  }>\n) => {\n  describe(name, () => {\n    let utils: any;\n\n    beforeAll(async () => {\n      utils = await import(utilsPath);\n    });\n\n    testCases.forEach(({name: testName, input, expectedOutput}) => {\n      it(`should ${testName}`, () => {\n        let result;\n        if((utils as {logInfo?: (input: TestArgs) => TestReturnValue}).logInfo) {\n          result = (utils as {logInfo: (input: TestArgs) => TestReturnValue}).logInfo(input);\n        } else if((utils as {removeEmptyKeys?: (input: TestArgs) => TestReturnValue}).removeEmptyKeys) {\n          result = (utils as {removeEmptyKeys: (input: TestArgs) => TestReturnValue}).removeEmptyKeys(input);\n        } else {\n          throw new Error(`No suitable function found in ${utilsPath}`);\n        }\n        expect(result).toEqual(expectedOutput);\n      });\n    });\n  });\n};"],
  "mappings": "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",
  "names": ["jest", "createMockContext", "overrides", "defaultSession", "overrideSession", "context", "createMockResolveInfo", "fieldName", "mockActionsModule", "modulePath", "mockActions", "mocks", "acc", "key", "value", "mockObjectType", "typeName", "mock", "createQueryTestSuite", "name", "actionsPath", "testCases", "actions", "mockContext", "testName", "actionName", "args", "expectedCall", "mockReturnValue", "errorCase", "mockFn", "result", "createMutationTestSuite", "requiresAuth", "authUserId", "createIntegrationTestSuite", "objectTypePath", "successReturnValue", "errorReturnValue", "testErrorCase", "createMockUser", "createMockPost", "createMockMessage", "createMockReaction", "createMockTag", "setupCommonMocks", "clearAllMocks", "createActionTestSuite", "mockQuery", "expectedResult", "mockDb", "actual", "createAdapterTestSuite", "adapterPath", "adapter", "input", "expectedOutput", "createUtilsTestSuite", "utilsPath", "utils"]
}

+/**
+ * Copyright (c) 2025-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { jest } from '@jest/globals';
+export const createMockContext = (overrides = {})=>{
+    const defaultSession = {
+        userAccess: 1,
+        userId: 'user1',
+        username: 'testuser'
+    };
+    const overrideSession = overrides.session || {};
+    const context = {
+        databaseName: overrides.databaseName ?? 'test',
+        ...overrides
+    };
+    delete context.session;
+    context.session = {
+        userAccess: overrideSession.userAccess !== undefined ? overrideSession.userAccess : defaultSession.userAccess,
+        userId: overrideSession.userId !== undefined ? overrideSession.userId : defaultSession.userId,
+        username: overrideSession.username !== undefined ? overrideSession.username : defaultSession.username
+    };
+    return context;
+};
+// Common mock resolve info for GraphQL resolvers
+export const createMockResolveInfo = (fieldName = 'test')=>{
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const operation = {};
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const parentType = {};
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const returnType = {};
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const schema = {};
+    return {
+        fieldName,
+        fieldNodes: [],
+        fragments: {},
+        operation,
+        parentType,
+        path: {
+            key: fieldName,
+            prev: undefined,
+            typename: 'Test'
+        },
+        returnType,
+        rootValue: {},
+        schema,
+        variableValues: {}
+    };
+};
+// Utility to mock actions module
+export const mockActionsModule = async (modulePath, mockActions)=>{
+    const mocks = Object.entries(mockActions).reduce((acc, [key, value])=>{
+        acc[key] = jest.fn().mockImplementation(value);
+        return acc;
+    }, {});
+    await jest.isolateModulesAsync(async ()=>{
+        jest.unstable_mockModule(modulePath, ()=>({
+                __esModule: true,
+                ...mocks,
+                default: mocks
+            }));
+    });
+};
+// Utility to mock object types
+export const mockObjectType = async (modulePath, typeName)=>{
+    const mock = {
+        __esModule: true,
+        [typeName]: {
+            getField: jest.fn(()=>({
+                    resolve: jest.fn()
+                })),
+            getFields: jest.fn(()=>({}))
+        },
+        default: {
+            [typeName]: {
+                getField: jest.fn(()=>({
+                        resolve: jest.fn()
+                    })),
+                getFields: jest.fn(()=>({}))
+            }
+        }
+    };
+    await jest.isolateModulesAsync(async ()=>{
+        jest.unstable_mockModule(modulePath, ()=>mock);
+    });
+};
+// Utility to create a test suite for query resolvers
+export const createQueryTestSuite = (name, actionsPath, testCases)=>{
+    describe(`${name} Queries`, ()=>{
+        let actions;
+        const mockContext = createMockContext();
+        beforeAll(()=>{
+            actions = {};
+        });
+        testCases.forEach(({ name: testName, actionName, args, expectedCall, mockReturnValue, errorCase = false })=>{
+            it(`should call ${actionName} action with correct parameters`, async ()=>{
+                const mockFn = jest.fn().mockImplementation(()=>Promise.resolve(mockReturnValue));
+                actions[actionName] = mockFn;
+                const result = await mockFn(mockContext, args);
+                expect(mockFn).toHaveBeenCalledWith(mockContext, expectedCall(mockContext, args));
+                expect(result).toEqual(mockReturnValue);
+            });
+            if (errorCase) {
+                it(`should handle ${actionName} when no data found`, async ()=>{
+                    const mockFn = jest.fn().mockImplementation(()=>Promise.resolve(null));
+                    actions[actionName] = mockFn;
+                    const result = await mockFn(mockContext, args);
+                    expect(mockFn).toHaveBeenCalledWith(mockContext, expectedCall(mockContext, args));
+                    expect(result).toBeNull();
+                });
+            }
+        });
+    });
+};
+// Utility to create a test suite for mutation resolvers
+export const createMutationTestSuite = (name, actionsPath, testCases)=>{
+    describe(`${name} Mutations`, ()=>{
+        let actions;
+        beforeAll(()=>{
+            actions = {};
+        });
+        testCases.forEach(({ actionName, args, expectedCall, mockReturnValue, requiresAuth = false, authUserId })=>{
+            it(`should call ${actionName} action with correct parameters`, async ()=>{
+                const mockContext = createMockContext();
+                if (requiresAuth && authUserId) {
+                    mockContext.session.userId = authUserId;
+                }
+                const mockFn = jest.fn().mockImplementation(()=>Promise.resolve(mockReturnValue));
+                actions[actionName] = mockFn;
+                const result = await mockFn(mockContext, args);
+                expect(mockFn).toHaveBeenCalledWith(mockContext, expectedCall(mockContext, args));
+                expect(result).toEqual(mockReturnValue);
+            });
+        });
+    });
+};
+// Utility to create integration test suite
+export const createIntegrationTestSuite = (name, actionsPath, objectTypePath, typeName, testCases)=>{
+    describe(`${name} Integration`, ()=>{
+        let actions;
+        beforeAll(()=>{
+            actions = {};
+        });
+        testCases.forEach(({ name: testName, actionName, args, expectedCall, successReturnValue, errorReturnValue, testErrorCase })=>{
+            describe(testName, ()=>{
+                it(`should return data when ${actionName} succeeds`, async ()=>{
+                    const mockContext = createMockContext();
+                    const mockFn = jest.fn().mockImplementation(()=>Promise.resolve(successReturnValue));
+                    actions[actionName] = mockFn;
+                    const result = await mockFn(mockContext, args);
+                    expect(mockFn).toHaveBeenCalledWith(mockContext, expectedCall(mockContext, args));
+                    expect(result).toEqual(successReturnValue || {});
+                });
+                if (testErrorCase) {
+                    it(`should handle ${actionName} when no data found`, async ()=>{
+                        const mockContext = createMockContext();
+                        const mockFn = jest.fn().mockImplementation(()=>Promise.resolve(errorReturnValue));
+                        actions[actionName] = mockFn;
+                        const result = await mockFn(mockContext, args);
+                        expect(mockFn).toHaveBeenCalledWith(mockContext, expectedCall(mockContext, args));
+                        expect(result).toEqual(errorReturnValue);
+                    });
+                }
+            });
+        });
+    });
+};
+// Common mock data generators
+export const createMockUser = (overrides = {})=>({
+        email: 'test@example.com',
+        firstName: 'Test',
+        lastName: 'User',
+        userId: 'user1',
+        username: 'testuser',
+        ...overrides
+    });
+export const createMockPost = (overrides = {})=>({
+        content: 'Test post content',
+        createdAt: new Date().toISOString(),
+        postId: 'post1',
+        userId: 'user1',
+        ...overrides
+    });
+export const createMockMessage = (overrides = {})=>({
+        content: 'Test message',
+        conversationId: 'conv1',
+        createdAt: new Date().toISOString(),
+        messageId: 'msg1',
+        userId: 'user1',
+        ...overrides
+    });
+export const createMockReaction = (overrides = {})=>({
+        createdAt: new Date().toISOString(),
+        postId: 'post1',
+        reactionId: 'react1',
+        type: 'like',
+        userId: 'user1',
+        ...overrides
+    });
+export const createMockTag = (overrides = {})=>({
+        description: 'Test tag description',
+        name: 'test-tag',
+        tagId: 'tag1',
+        ...overrides
+    });
+// Utility to set up common mocks
+export const setupCommonMocks = async ()=>{
+    const mock = {
+        __esModule: true,
+        useDb: jest.fn(),
+        getLimit: jest.fn(),
+        getDocId: jest.fn(),
+        sortIds: jest.fn(),
+        getGqlFields: jest.fn(),
+        default: {
+            useDb: jest.fn(),
+            getLimit: jest.fn(),
+            getDocId: jest.fn(),
+            sortIds: jest.fn(),
+            getGqlFields: jest.fn()
+        }
+    };
+    await jest.isolateModulesAsync(async ()=>{
+        jest.unstable_mockModule('./arangodbUtils.js', ()=>mock);
+    });
+};
+// Utility to clear all mocks
+export const clearAllMocks = ()=>{
+    jest.clearAllMocks();
+};
+// Utility to create a test suite for action functions
+export const createActionTestSuite = (name, actionsPath, testCases)=>{
+    describe(`${name} actions`, ()=>{
+        let actions;
+        beforeAll(async ()=>{
+            actions = await import(actionsPath);
+        });
+        testCases.forEach(({ name: testName, actionName, args, mockQuery, expectedResult })=>{
+            it(`should execute ${actionName}`, async ()=>{
+                const mockContext = createMockContext();
+                const mockDb = jest.fn().mockReturnValue({
+                    query: mockQuery
+                });
+                const actual = jest.requireActual('./arangodbUtils.js');
+                jest.doMock('./arangodbUtils.js', ()=>({
+                        useDb: mockDb,
+                        ...actual
+                    }));
+                const result = await actions[actionName](mockContext, args);
+                expect(result).toEqual(expectedResult);
+            });
+        });
+    });
+};
+export const createAdapterTestSuite = (name, adapterPath, testCases)=>{
+    describe(name, ()=>{
+        let adapter;
+        beforeAll(async ()=>{
+            adapter = await import(adapterPath);
+        });
+        testCases.forEach(({ name: testName, input, expectedOutput })=>{
+            it(`should ${testName}`, ()=>{
+                const result = adapter.parseTag(input);
+                expect(result).toEqual(expectedOutput);
+            });
+        });
+    });
+};
+export const createUtilsTestSuite = (name, utilsPath, testCases)=>{
+    describe(name, ()=>{
+        let utils;
+        beforeAll(async ()=>{
+            utils = await import(utilsPath);
+        });
+        testCases.forEach(({ name: testName, input, expectedOutput })=>{
+            it(`should ${testName}`, ()=>{
+                let result;
+                if (utils.logInfo) {
+                    result = utils.logInfo(input);
+                } else if (utils.removeEmptyKeys) {
+                    result = utils.removeEmptyKeys(input);
+                } else {
+                    throw new Error(`No suitable function found in ${utilsPath}`);
+                }
+                expect(result).toEqual(expectedOutput);
+            });
+        });
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/src/utils/testUtils.ts"],"sourcesContent":["/**\n * Copyright (c) 2025-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {jest} from '@jest/globals';\nimport type {GraphQLResolveInfo} from 'graphql';\n\n\nimport type {ApiContext} from '../types/auth.types.js';\n\n// Define proper types for test utilities\ntype MockOverrides = Partial<Record<string, unknown>>;\ntype TestContext = Partial<ApiContext> & {session?: Partial<{userId: string; username: string; userAccess: number}>};\ntype TestArgs = Record<string, unknown>;\ntype TestReturnValue = unknown;\n\nexport const createMockContext = (overrides: MockOverrides = {}): ApiContext => {\n  const defaultSession = {\n    userAccess: 1,\n    userId: 'user1',\n    username: 'testuser'\n  };\n  const overrideSession: Partial<typeof defaultSession> = overrides.session || {};\n  const context: TestContext = {\n    databaseName: (overrides.databaseName as string) ?? 'test',\n    ...overrides\n  };\n  delete context.session;\n  context.session = {\n    userAccess: overrideSession.userAccess !== undefined ? overrideSession.userAccess : defaultSession.userAccess,\n    userId: overrideSession.userId !== undefined ? overrideSession.userId : defaultSession.userId,\n    username: overrideSession.username !== undefined ? overrideSession.username : defaultSession.username\n  };\n  return context as ApiContext;\n};\n\n// Common mock resolve info for GraphQL resolvers\nexport const createMockResolveInfo = (fieldName: string = 'test'): GraphQLResolveInfo => {\n  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n  const operation = {} as GraphQLResolveInfo['operation'];\n  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n  const parentType = {} as GraphQLResolveInfo['parentType'];\n  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n  const returnType = {} as GraphQLResolveInfo['returnType'];\n  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n  const schema = {} as GraphQLResolveInfo['schema'];\n\n  return {\n    fieldName,\n    fieldNodes: [],\n    fragments: {},\n    operation,\n    parentType,\n    path: {key: fieldName, prev: undefined, typename: 'Test'},\n    returnType,\n    rootValue: {},\n    schema,\n    variableValues: {}\n  };\n};\n\n// Utility to mock actions module\nexport const mockActionsModule = async (modulePath: string, mockActions: Record<string, jest.Mock>) => {\n  const mocks = Object.entries(mockActions).reduce((acc, [key, value]) => {\n    acc[key] = jest.fn().mockImplementation(value);\n    return acc;\n  }, {} as Record<string, jest.Mock>);\n\n  await jest.isolateModulesAsync(async () => {\n    jest.unstable_mockModule(modulePath, () => ({\n      __esModule: true,\n      ...mocks,\n      default: mocks\n    }));\n  });\n};\n\n// Utility to mock object types\nexport const mockObjectType = async (modulePath: string, typeName: string) => {\n  const mock = {\n    __esModule: true,\n    [typeName]: {\n      getField: jest.fn(() => ({resolve: jest.fn()})),\n      getFields: jest.fn(() => ({}))\n    },\n    default: {\n      [typeName]: {\n        getField: jest.fn(() => ({resolve: jest.fn()})),\n        getFields: jest.fn(() => ({}))\n      }\n    }\n  };\n  await jest.isolateModulesAsync(async () => {\n    jest.unstable_mockModule(modulePath, () => mock);\n  });\n};\n\n// Utility to create a test suite for query resolvers\nexport const createQueryTestSuite = (\n  name: string,\n  actionsPath: string,\n  testCases: Array<{\n    name: string;\n    actionName: string;\n    args: TestArgs;\n    expectedCall: (context: TestContext, args: TestArgs) => TestArgs;\n    mockReturnValue: TestReturnValue;\n    errorCase?: boolean;\n  }>\n) => {\n  describe(`${name} Queries`, () => {\n    let actions: any;\n    const mockContext = createMockContext();\n\n    beforeAll(() => {\n      actions = {};\n    });\n\n    testCases.forEach(({name: testName, actionName, args, expectedCall, mockReturnValue, errorCase = false}) => {\n      it(`should call ${actionName} action with correct parameters`, async () => {\n        const mockFn = jest.fn().mockImplementation(() => Promise.resolve(mockReturnValue));\n        actions[actionName] = mockFn;\n\n        const result = await mockFn(mockContext, args);\n        expect(mockFn).toHaveBeenCalledWith(mockContext, expectedCall(mockContext, args));\n        expect(result).toEqual(mockReturnValue);\n      });\n\n      if(errorCase) {\n        it(`should handle ${actionName} when no data found`, async () => {\n          const mockFn = jest.fn().mockImplementation(() => Promise.resolve(null));\n          actions[actionName] = mockFn;\n\n          const result = await mockFn(mockContext, args);\n          expect(mockFn).toHaveBeenCalledWith(mockContext, expectedCall(mockContext, args));\n          expect(result).toBeNull();\n        });\n      }\n    });\n  });\n};\n\n// Utility to create a test suite for mutation resolvers\nexport const createMutationTestSuite = (\n  name: string,\n  actionsPath: string,\n  testCases: Array<{\n    name: string;\n    actionName: string;\n    args: TestArgs;\n    expectedCall: (context: TestContext, args: TestArgs) => TestArgs;\n    mockReturnValue: TestReturnValue;\n    requiresAuth?: boolean;\n    authUserId?: string;\n  }>\n) => {\n  describe(`${name} Mutations`, () => {\n    let actions: any;\n\n    beforeAll(() => {\n      actions = {};\n    });\n\n    testCases.forEach(({\n      actionName,\n      args,\n      expectedCall,\n      mockReturnValue,\n      requiresAuth = false,\n      authUserId\n    }) => {\n      it(`should call ${actionName} action with correct parameters`, async () => {\n        const mockContext = createMockContext();\n        if(requiresAuth && authUserId) {\n          (mockContext.session as {userId: string}).userId = authUserId;\n        }\n\n        const mockFn = jest.fn().mockImplementation(() => Promise.resolve(mockReturnValue));\n        actions[actionName] = mockFn;\n\n        const result = await mockFn(mockContext, args);\n        expect(mockFn).toHaveBeenCalledWith(mockContext, expectedCall(mockContext, args));\n        expect(result).toEqual(mockReturnValue);\n      });\n    });\n  });\n};\n\n// Utility to create integration test suite\nexport const createIntegrationTestSuite = (\n  name: string,\n  actionsPath: string,\n  objectTypePath: string,\n  typeName: string,\n  testCases: Array<{\n    name: string;\n    actionName: string;\n    args: TestArgs;\n    expectedCall: (context: TestContext, args: TestArgs) => TestArgs;\n    successReturnValue: TestReturnValue;\n    errorReturnValue: TestReturnValue;\n    testErrorCase: boolean;\n  }>\n) => {\n  describe(`${name} Integration`, () => {\n    let actions: any;\n\n    beforeAll(() => {\n      actions = {};\n    });\n\n    testCases.forEach(({\n      name: testName,\n      actionName,\n      args,\n      expectedCall,\n      successReturnValue,\n      errorReturnValue,\n      testErrorCase\n    }) => {\n      describe(testName, () => {\n        it(`should return data when ${actionName} succeeds`, async () => {\n          const mockContext = createMockContext();\n          const mockFn = jest.fn().mockImplementation(() => Promise.resolve(successReturnValue));\n          actions[actionName] = mockFn;\n\n          const result = await mockFn(mockContext, args);\n\n          expect(mockFn).toHaveBeenCalledWith(mockContext, expectedCall(mockContext, args));\n          expect(result).toEqual(successReturnValue || {});\n        });\n\n        if(testErrorCase) {\n          it(`should handle ${actionName} when no data found`, async () => {\n            const mockContext = createMockContext();\n            const mockFn = jest.fn().mockImplementation(() => Promise.resolve(errorReturnValue));\n            actions[actionName] = mockFn;\n\n            const result = await mockFn(mockContext, args);\n\n            expect(mockFn).toHaveBeenCalledWith(mockContext, expectedCall(mockContext, args));\n            expect(result).toEqual(errorReturnValue);\n          });\n        }\n      });\n    });\n  });\n};\n\n// Common mock data generators\nexport const createMockUser = (overrides: MockOverrides = {}) => ({\n  email: 'test@example.com',\n  firstName: 'Test',\n  lastName: 'User',\n  userId: 'user1',\n  username: 'testuser',\n  ...overrides\n});\n\nexport const createMockPost = (overrides: MockOverrides = {}) => ({\n  content: 'Test post content',\n  createdAt: new Date().toISOString(),\n  postId: 'post1',\n  userId: 'user1',\n  ...overrides\n});\n\nexport const createMockMessage = (overrides: MockOverrides = {}) => ({\n  content: 'Test message',\n  conversationId: 'conv1',\n  createdAt: new Date().toISOString(),\n  messageId: 'msg1',\n  userId: 'user1',\n  ...overrides\n});\n\nexport const createMockReaction = (overrides: MockOverrides = {}) => ({\n  createdAt: new Date().toISOString(),\n  postId: 'post1',\n  reactionId: 'react1',\n  type: 'like',\n  userId: 'user1',\n  ...overrides\n});\n\nexport const createMockTag = (overrides: MockOverrides = {}) => ({\n  description: 'Test tag description',\n  name: 'test-tag',\n  tagId: 'tag1',\n  ...overrides\n});\n\n// Utility to set up common mocks\nexport const setupCommonMocks = async () => {\n  const mock = {\n    __esModule: true,\n    useDb: jest.fn(),\n    getLimit: jest.fn(),\n    getDocId: jest.fn(),\n    sortIds: jest.fn(),\n    getGqlFields: jest.fn(),\n    default: {\n      useDb: jest.fn(),\n      getLimit: jest.fn(),\n      getDocId: jest.fn(),\n      sortIds: jest.fn(),\n      getGqlFields: jest.fn()\n    }\n  };\n  await jest.isolateModulesAsync(async () => {\n    jest.unstable_mockModule('./arangodbUtils.js', () => mock);\n  });\n};\n\n// Utility to clear all mocks\nexport const clearAllMocks = () => {\n  jest.clearAllMocks();\n};\n\n// Utility to create a test suite for action functions\nexport const createActionTestSuite = (\n  name: string,\n  actionsPath: string,\n  testCases: Array<{\n    name: string;\n    actionName: string;\n    args: TestArgs;\n    mockQuery: jest.Mock;\n    expectedResult: TestReturnValue;\n  }>\n) => {\n  describe(`${name} actions`, () => {\n    let actions: any;\n\n    beforeAll(async () => {\n      actions = await import(actionsPath);\n    });\n\n    testCases.forEach(({name: testName, actionName, args, mockQuery, expectedResult}) => {\n      it(`should execute ${actionName}`, async () => {\n        const mockContext = createMockContext();\n        const mockDb = jest.fn().mockReturnValue({\n          query: mockQuery\n        });\n        const actual = jest.requireActual('./arangodbUtils.js') as Record<string, unknown>;\n        jest.doMock('./arangodbUtils.js', () => ({\n          useDb: mockDb,\n          ...actual\n        }));\n\n        const result = await (actions[actionName] as jest.Mock)(mockContext, args);\n        expect(result).toEqual(expectedResult);\n      });\n    });\n  });\n};\n\nexport const createAdapterTestSuite = (\n  name: string,\n  adapterPath: string,\n  testCases: any[]\n) => {\n  describe(name, () => {\n    let adapter: any;\n\n    beforeAll(async () => {\n      adapter = await import(adapterPath);\n    });\n\n    testCases.forEach(({name: testName, input, expectedOutput}) => {\n      it(`should ${testName}`, () => {\n        const result = (adapter as {parseTag: (input: TestArgs) => TestReturnValue}).parseTag(input);\n        expect(result).toEqual(expectedOutput);\n      });\n    });\n  });\n};\n\nexport const createUtilsTestSuite = (\n  name: string,\n  utilsPath: string,\n  testCases: Array<{\n    name: string;\n    input: TestArgs;\n    expectedOutput: TestReturnValue;\n  }>\n) => {\n  describe(name, () => {\n    let utils: any;\n\n    beforeAll(async () => {\n      utils = await import(utilsPath);\n    });\n\n    testCases.forEach(({name: testName, input, expectedOutput}) => {\n      it(`should ${testName}`, () => {\n        let result;\n        if((utils as {logInfo?: (input: TestArgs) => TestReturnValue}).logInfo) {\n          result = (utils as {logInfo: (input: TestArgs) => TestReturnValue}).logInfo(input);\n        } else if((utils as {removeEmptyKeys?: (input: TestArgs) => TestReturnValue}).removeEmptyKeys) {\n          result = (utils as {removeEmptyKeys: (input: TestArgs) => TestReturnValue}).removeEmptyKeys(input);\n        } else {\n          throw new Error(`No suitable function found in ${utilsPath}`);\n        }\n        expect(result).toEqual(expectedOutput);\n      });\n    });\n  });\n};"],"names":["jest","createMockContext","overrides","defaultSession","userAccess","userId","username","overrideSession","session","context","databaseName","undefined","createMockResolveInfo","fieldName","operation","parentType","returnType","schema","fieldNodes","fragments","path","key","prev","typename","rootValue","variableValues","mockActionsModule","modulePath","mockActions","mocks","Object","entries","reduce","acc","value","fn","mockImplementation","isolateModulesAsync","unstable_mockModule","__esModule","default","mockObjectType","typeName","mock","getField","resolve","getFields","createQueryTestSuite","name","actionsPath","testCases","describe","actions","mockContext","beforeAll","forEach","testName","actionName","args","expectedCall","mockReturnValue","errorCase","it","mockFn","Promise","result","expect","toHaveBeenCalledWith","toEqual","toBeNull","createMutationTestSuite","requiresAuth","authUserId","createIntegrationTestSuite","objectTypePath","successReturnValue","errorReturnValue","testErrorCase","createMockUser","email","firstName","lastName","createMockPost","content","createdAt","Date","toISOString","postId","createMockMessage","conversationId","messageId","createMockReaction","reactionId","type","createMockTag","description","tagId","setupCommonMocks","useDb","getLimit","getDocId","sortIds","getGqlFields","clearAllMocks","createActionTestSuite","mockQuery","expectedResult","mockDb","query","actual","requireActual","doMock","createAdapterTestSuite","adapterPath","adapter","input","expectedOutput","parseTag","createUtilsTestSuite","utilsPath","utils","logInfo","removeEmptyKeys","Error"],"mappings":"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"}

package/lib/utils/translationQueue.d.ts

@@ -27,3 +27,4 @@ export declare const flush: () => Promise<void>;
 export declare const clear: () => void;
 export type { TranslationObject };
 export { translationQueue };
+//# sourceMappingURL=translationQueue.d.ts.map

package/lib/utils/translationQueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translationQueue.d.ts","sourceRoot":"","sources":["../../src/utils/translationQueue.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,wBAAwB,CAAC;AACvD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,2BAA2B,CAAC;AAiBtD,UAAU,iBAAiB;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC9B;AAED,cAAM,gBAAgB;IACpB,OAAO,CAAC,OAAO,CAA4C;IAC3D,OAAO,CAAC,YAAY,CAAM;IAC1B,OAAO,CAAC,YAAY,CAAM;IAEpB,SAAS,CACb,OAAO,EAAE,UAAU,EACnB,YAAY,EAAE,iBAAiB,EAAE,EACjC,MAAM,GAAE,MAAa,GACpB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;YAmBpB,cAAc;IAiCtB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAK5B,KAAK,IAAI,IAAI;IAUb,OAAO,CAAC,WAAW;YAIL,YAAY;IAuC1B,OAAO,CAAC,WAAW;CAGpB;AAED,QAAA,MAAM,gBAAgB,kBAAyB,CAAC;AAEhD,eAAO,MAAM,IAAI,GACf,SAAS,UAAU,EACnB,cAAc,iBAAiB,EAAE,EACjC,SAAS,MAAM,KACd,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAA8D,CAAC;AAEhG,eAAO,MAAM,KAAK,QAAO,OAAO,CAAC,IAAI,CAA6B,CAAC;AACnE,eAAO,MAAM,KAAK,QAAO,IAAgC,CAAC;AAE1D,YAAY,EAAC,iBAAiB,EAAC,CAAC;AAE9B,OAAO,EAAC,gBAAgB,EAAC,CAAC"}

package/lib/utils/translationQueue.example.d.ts

@@ -31,3 +31,4 @@ export declare function getNotificationMessages(context: ApiContext, locale?: Lo
 export declare function performanceComparison(context: ApiContext): Promise<Record<string, string>>;
 export declare function getUserGreeting(context: ApiContext, userLocale?: string, username?: string): Promise<string>;
 export declare function ensureAllTranslationsProcessed(): Promise<void>;
+//# sourceMappingURL=translationQueue.example.d.ts.map

package/lib/utils/translationQueue.example.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translationQueue.example.d.ts","sourceRoot":"","sources":["../../src/utils/translationQueue.example.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,wBAAwB,CAAC;AACvD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,2BAA2B,CAAC;AAGtD,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,UAAU,EAAE,MAAM,GAAE,MAAa,mCA6BlF;AAGD,wBAAsB,uBAAuB,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAE,MAAa,mCA2BzG;AAGD,wBAAsB,uBAAuB,CAAC,OAAO,EAAE,UAAU,mDA0BhE;AAGD,wBAAsB,qBAAqB,CAAC,OAAO,EAAE,UAAU,EAAE,MAAM,GAAE,MAAa,mCA2BrF;AAGD,wBAAsB,4BAA4B,CAAC,OAAO,EAAE,UAAU,EAAE,MAAM,GAAE,MAAa,mCAmB5F;AAGD,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,GAAE,MAAa,mCAuBnG;AAGD,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,UAAU,EACnB,QAAQ,EAAE;IACR,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,EACD,MAAM,GAAE,MAAa;;;;;GAoCtB;AAGD,wBAAsB,uBAAuB,CAAC,OAAO,EAAE,UAAU,EAAE,MAAM,GAAE,MAAa,mCA4BvF;AAGD,wBAAsB,qBAAqB,CAAC,OAAO,EAAE,UAAU,mCAgB9D;AAGD,wBAAsB,eAAe,CACnC,OAAO,EAAE,UAAU,EACnB,UAAU,CAAC,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE,MAAM,mBAiClB;AAGD,wBAAsB,8BAA8B,kBAInD"}