@stonecrop/casl-middleware 0.11.0 → 0.11.1

package/dist/tests/middleware.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=middleware.test.d.ts.map

package/dist/tests/middleware.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"middleware.test.d.ts","sourceRoot":"","sources":["../../tests/middleware.test.ts"],"names":[],"mappings":""}

package/dist/tests/middleware.test.js

@@ -1,184 +0,0 @@
-import { PureAbility, AbilityBuilder } from '@casl/ability';
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { createCaslMiddleware } from '../src/middleware/graphql';
-const Ability = PureAbility;
-// Helper to create abilities with proper matchers
-const createTestAbility = (rules) => {
-    const { can, cannot, build } = new AbilityBuilder(Ability);
-    rules.forEach(rule => {
-        if (rule.inverted) {
-            if (rule.fields && rule.conditions) {
-                cannot(rule.action, rule.subject, rule.fields, rule.conditions);
-            }
-            else if (rule.fields) {
-                cannot(rule.action, rule.subject, rule.fields);
-            }
-            else if (rule.conditions) {
-                cannot(rule.action, rule.subject, rule.conditions);
-            }
-            else {
-                cannot(rule.action, rule.subject);
-            }
-        }
-        else {
-            if (rule.fields && rule.conditions) {
-                can(rule.action, rule.subject, rule.fields, rule.conditions);
-            }
-            else if (rule.fields) {
-                can(rule.action, rule.subject, rule.fields);
-            }
-            else if (rule.conditions) {
-                can(rule.action, rule.subject, rule.conditions);
-            }
-            else {
-                can(rule.action, rule.subject);
-            }
-        }
-    });
-    return build({
-        detectSubjectType: (object) => object?.type || object?.constructor?.name || 'Unknown',
-        fieldMatcher: fields => field => {
-            if (!fields || !field)
-                return false;
-            return Array.isArray(fields) ? fields.includes(field) : fields === field;
-        },
-        conditionsMatcher: conditions => object => {
-            if (!conditions || !object)
-                return true;
-            return Object.keys(conditions).every(key => object[key] === conditions[key]);
-        },
-    });
-};
-describe('CASL GraphQL Middleware', () => {
-    let mockResolve;
-    let mockContext;
-    let mockInfo;
-    beforeEach(() => {
-        mockResolve = vi.fn().mockResolvedValue({ data: 'test' });
-        mockContext = {
-            ability: createTestAbility([
-                { action: 'read', subject: 'Query' },
-                { action: 'read', subject: 'User' },
-                { action: 'update', subject: 'User', conditions: { id: '123' } },
-            ]),
-            user: { id: '123', roles: ['user'] },
-        };
-        mockInfo = {
-            fieldName: 'getUser',
-            parentType: { name: 'Query' },
-            path: { typename: 'Query', key: 'getUser' },
-            operation: {
-                operation: 'query',
-                loc: { source: { body: 'query { getUser { id } }' } },
-            },
-        };
-    });
-    describe('Basic Middleware Functionality', () => {
-        it('should pass through when ability allows the operation', async () => {
-            const middleware = createCaslMiddleware();
-            const result = await middleware(mockResolve, {}, {}, mockContext, mockInfo);
-            expect(mockResolve).toHaveBeenCalled();
-            expect(result).toEqual({ data: 'test' });
-        });
-        it('should create ability when not in context', async () => {
-            const middleware = createCaslMiddleware();
-            const contextWithoutAbility = { user: { id: '123', roles: ['user'] } };
-            // The middleware creates an ability if none exists
-            const result = await middleware(mockResolve, {}, {}, contextWithoutAbility, mockInfo);
-            expect(mockResolve).toHaveBeenCalled();
-            expect(result).toEqual({ data: 'test' });
-            expect(contextWithoutAbility.ability).toBeDefined();
-        });
-        it('should deny access when ability does not allow operation', async () => {
-            const middleware = createCaslMiddleware();
-            mockContext.ability = createTestAbility([{ action: 'read', subject: 'Post' }]);
-            await expect(middleware(mockResolve, {}, {}, mockContext, mockInfo)).rejects.toThrow('Access denied for read on Query');
-        });
-    });
-    describe('Subject Mapping', () => {
-        it('should map GraphQL types to custom subjects', async () => {
-            const middleware = createCaslMiddleware({
-                subjectMap: {
-                    Query: 'query_operations',
-                    User: 'app_user',
-                },
-            });
-            mockContext.ability = createTestAbility([{ action: 'read', subject: 'query_operations' }]);
-            const result = await middleware(mockResolve, {}, {}, mockContext, mockInfo);
-            expect(mockResolve).toHaveBeenCalled();
-            expect(result).toEqual({ data: 'test' });
-        });
-        it('should use original type name when no mapping exists', async () => {
-            const middleware = createCaslMiddleware({
-                subjectMap: { User: 'app_user' },
-            });
-            // Should work with original 'Query' subject since it's not mapped
-            const result = await middleware(mockResolve, {}, {}, mockContext, mockInfo);
-            expect(mockResolve).toHaveBeenCalled();
-        });
-    });
-    describe('Action Mapping', () => {
-        it('should map GraphQL operations to custom actions', async () => {
-            const middleware = createCaslMiddleware({
-                actionMap: {
-                    query: 'view',
-                    mutation: 'modify',
-                    subscription: 'watch',
-                },
-            });
-            mockContext.ability = createTestAbility([{ action: 'view', subject: 'Query' }]);
-            const result = await middleware(mockResolve, {}, {}, mockContext, mockInfo);
-            expect(mockResolve).toHaveBeenCalled();
-        });
-    });
-    describe('Field-Level Permissions', () => {
-        it('should check field-level permissions when configured', async () => {
-            const middleware = createCaslMiddleware({
-                fieldPermissions: {
-                    'User.email': [{ action: 'read', subject: 'UserEmail' }],
-                    'User.password': [{ action: 'read', subject: 'UserPassword' }],
-                },
-            });
-            mockInfo.parentType = { name: 'User' };
-            mockInfo.fieldName = 'email';
-            mockInfo.path = { typename: 'User', key: 'email' };
-            mockContext.ability = createTestAbility([
-                { action: 'read', subject: 'User' },
-                { action: 'read', subject: 'UserEmail' },
-            ]);
-            const result = await middleware(mockResolve, {}, {}, mockContext, mockInfo);
-            expect(mockResolve).toHaveBeenCalled();
-        });
-        it('should deny access to fields without permission', async () => {
-            const middleware = createCaslMiddleware({
-                fieldPermissions: {
-                    'User.password': [{ action: 'read', subject: 'UserPassword' }],
-                },
-            });
-            mockInfo.parentType = { name: 'User' };
-            mockInfo.fieldName = 'password';
-            mockInfo.path = { typename: 'User', key: 'password' };
-            mockContext.ability = createTestAbility([{ action: 'read', subject: 'User' }]);
-            await expect(middleware(mockResolve, {}, {}, mockContext, mockInfo)).rejects.toThrow('Access denied for field User.password');
-        });
-    });
-    describe('Mutation Field Checking', () => {
-        it('should check field permissions for mutations with input', async () => {
-            const middleware = createCaslMiddleware();
-            mockInfo.parentType = { name: 'Mutation' };
-            mockInfo.operation.operation = 'mutation';
-            mockInfo.operation.loc = {
-                source: {
-                    body: 'mutation { updateUser(input: { name: "test", role: "admin" }) { id } }',
-                },
-            };
-            mockContext.ability = createTestAbility([
-                { action: 'update', subject: 'Mutation' },
-                { action: 'update', subject: 'User', fields: ['name'] },
-            ]);
-            const args = { input: { name: 'test', role: 'admin' } };
-            const result = await middleware(mockResolve, {}, args, mockContext, mockInfo);
-            expect(mockResolve).toHaveBeenCalled();
-        });
-    });
-});

package/dist/tests/postgraphile-plugin.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=postgraphile-plugin.test.d.ts.map

package/dist/tests/postgraphile-plugin.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"postgraphile-plugin.test.d.ts","sourceRoot":"","sources":["../../tests/postgraphile-plugin.test.ts"],"names":[],"mappings":""}

package/dist/tests/postgraphile-plugin.test.js

@@ -1,56 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { pglCaslPlugin } from '../src';
-import { createConfigBasedAbilityBuilder } from '../src/middleware/ability';
-describe('PostGraphile CASL Plugins', () => {
-    describe('pglCaslPlugin (extendSchema)', () => {
-        it('should be a valid extendSchema plugin object', () => {
-            expect(pglCaslPlugin).toBeDefined();
-            expect(pglCaslPlugin).toBeInstanceOf(Object); // It's an object, not a function
-            expect(pglCaslPlugin).toHaveProperty('name');
-            expect(pglCaslPlugin).toHaveProperty('version');
-        });
-        it('should have schema extension properties', () => {
-            // The plugin object has specific properties
-            expect(pglCaslPlugin).toHaveProperty('name');
-            expect(pglCaslPlugin.name).toMatch(/^ExtendSchemaPlugin_/);
-            // Check for schema extension function
-            expect(pglCaslPlugin).toHaveProperty('schema');
-            expect(typeof pglCaslPlugin.schema).toBe('object');
-            // Check for hooks if they exist
-            if (pglCaslPlugin.schema?.hooks) {
-                expect(pglCaslPlugin.schema.hooks).toHaveProperty('build');
-            }
-        });
-        it('should define schema extensions when executed', () => {
-            // Since extendSchema creates a plugin object, we need to test differently
-            // The actual schema extension happens when PostGraphile processes the plugin
-            // We can verify the plugin has the expected structure
-            expect(pglCaslPlugin).toHaveProperty('name');
-            expect(pglCaslPlugin).toHaveProperty('version');
-            // The schema extension function is wrapped inside the plugin
-            // and will be executed by PostGraphile
-        });
-    });
-    describe('Ability Integration', () => {
-        it('should create abilities with custom builder', async () => {
-            const customBuilder = createConfigBasedAbilityBuilder({
-                defaultRules: [{ action: 'read', subject: 'Query' }],
-                roles: {
-                    editor: [
-                        { action: 'create', subject: 'Post' },
-                        { action: 'update', subject: 'Post' },
-                    ],
-                },
-            });
-            // Test that the ability builder works
-            const ability = await customBuilder({ id: '123', roles: ['editor'] });
-            expect(ability.can('create', 'Post')).toBe(true);
-            expect(ability.can('update', 'Post')).toBe(true);
-        });
-        it('should work with PostGraphile plugin system', () => {
-            // Test that our plugin has the correct shape for PostGraphile
-            expect(pglCaslPlugin).toHaveProperty('name');
-            expect(pglCaslPlugin).toHaveProperty('version');
-        });
-    });
-});

package/dist/tests/setup.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=setup.d.ts.map

package/dist/tests/setup.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../tests/setup.ts"],"names":[],"mappings":""}

package/dist/tests/setup.js

@@ -1,11 +0,0 @@
-import { beforeAll, afterEach, afterAll } from 'vitest';
-// Setup test environment
-beforeAll(() => {
-    // Add any global setup here
-});
-afterEach(() => {
-    // Clean up after each test
-});
-afterAll(() => {
-    // Clean up after all tests
-});

package/dist/tests/types.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=types.test.d.ts.map

package/dist/tests/types.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.test.d.ts","sourceRoot":"","sources":["../../tests/types.test.ts"],"names":[],"mappings":""}

package/dist/tests/types.test.js

@@ -1,143 +0,0 @@
-import { describe, it, expectTypeOf } from 'vitest';
-import { createAbility, detectSubjectType, defaultAbilityBuilder, createDatabaseAbilityBuilder, createConfigBasedAbilityBuilder, } from '../src/middleware/ability';
-import { createJWTMiddleware, createJWT } from '../src/middleware/jwt';
-import { createCaslMiddleware } from '../src/middleware/graphql';
-describe('Type Safety Tests', () => {
-    describe('Ability Types', () => {
-        it('should have correct AppAbility type structure', () => {
-            expectTypeOf().toExtend(); // AppAbility extends PureAbility base type
-        });
-        it('should infer correct return type for createAbility', async () => {
-            const ability = await createAbility({ id: '1', roles: ['user'] });
-            expectTypeOf(ability).toEqualTypeOf();
-        });
-        it('should accept AbilityBuilderFunction as parameter', () => {
-            const builder = user => defaultAbilityBuilder(user);
-            expectTypeOf(builder).parameter(0).toEqualTypeOf();
-            expectTypeOf(builder).returns.resolves.toEqualTypeOf();
-        });
-        it('should have correct detectSubjectType signature', () => {
-            expectTypeOf(detectSubjectType).parameter(0).toEqualTypeOf();
-            expectTypeOf(detectSubjectType).returns.toEqualTypeOf();
-        });
-        it('should type database ability builder correctly', () => {
-            const fetchRules = async (userId) => [];
-            const builder = createDatabaseAbilityBuilder(fetchRules);
-            expectTypeOf(builder).parameter(0).toEqualTypeOf();
-            expectTypeOf(builder).returns.resolves.toEqualTypeOf();
-        });
-        it('should type config-based ability builder correctly', () => {
-            const config = {
-                roles: {
-                    admin: [{ action: 'manage', subject: 'all' }],
-                },
-            };
-            const builder = createConfigBasedAbilityBuilder(config);
-            expectTypeOf(builder).parameter(0).toEqualTypeOf();
-            // Builder returns AppAbility synchronously
-            expectTypeOf(builder).toBeFunction();
-        });
-    });
-    describe('JWT Types', () => {
-        it('should have correct JWTConfig type structure', () => {
-            const config = {
-                secret: 'test',
-                enabled: true,
-                optional: false,
-            };
-            expectTypeOf(config).toExtend(); // Check config has at least these properties
-        });
-        it('should have correct JWTPayload structure', () => {
-            expectTypeOf().toHaveProperty('sub');
-            expectTypeOf().toHaveProperty('iat');
-        });
-        it('should infer correct return type for createJWT', () => {
-            const user = { id: '1', roles: ['user'] };
-            const token = createJWT(user, { secret: 'test' });
-            expectTypeOf(token).toBeString();
-        });
-        it('should type middleware correctly', () => {
-            const middleware = createJWTMiddleware({ secret: 'test' });
-            expectTypeOf(middleware).parameter(0).toEqualTypeOf();
-            expectTypeOf(middleware).parameter(1).toBeFunction();
-            expectTypeOf(middleware).returns.toEqualTypeOf();
-        });
-    });
-    describe('GraphQL Middleware Types', () => {
-        it('should have correct MiddlewareOptions type structure', () => {
-            const options = {
-                subjectMap: {},
-                actionMap: {},
-                fieldPermissions: {},
-                debug: false,
-            };
-            expectTypeOf(options).toExtend(); // Check options has at least these properties
-        });
-        it('should type middleware function correctly', () => {
-            const middleware = createCaslMiddleware();
-            expectTypeOf(middleware).toBeFunction();
-            expectTypeOf(middleware).parameter(0).toBeFunction(); // resolve
-            expectTypeOf(middleware).parameter(1).toBeAny(); // root
-            expectTypeOf(middleware).parameter(2).toBeAny(); // args
-            expectTypeOf(middleware).parameter(3).toEqualTypeOf(); // context
-            expectTypeOf(middleware).returns.toEqualTypeOf();
-        });
-    });
-    describe('Context Types', () => {
-        it('should have correct Context type structure', () => {
-            expectTypeOf().toHaveProperty('ability');
-            expectTypeOf().toHaveProperty('user');
-        });
-        it('should have correct User type structure', () => {
-            expectTypeOf().toHaveProperty('id');
-            expectTypeOf().toHaveProperty('roles');
-            const user = { id: '1', roles: ['admin'] };
-            expectTypeOf(user.id).toBeString();
-            // roles is optional, so check the array type when present
-            if (user.roles) {
-                expectTypeOf(user.roles).toEqualTypeOf();
-            }
-        });
-        it('should allow optional properties on User', () => {
-            const userWithOptionals = {
-                id: '1',
-                roles: ['user'],
-                email: 'test@example.com',
-            };
-            expectTypeOf(userWithOptionals).toExtend(); // Check that object is assignable to User type
-        });
-    });
-    describe('Ability Rule Types', () => {
-        it('should correctly type ability actions', () => {
-            const ability = defaultAbilityBuilder({ id: '1', roles: ['user'] });
-            // Type checking that these calls are valid
-            expectTypeOf(ability.can).parameter(0).toBeString();
-            expectTypeOf(ability.can).parameter(1).toEqualTypeOf();
-        });
-        it('should support subject type checking', () => {
-            const ability = defaultAbilityBuilder({ id: '1', roles: ['user'] });
-            // Verify can() method signature accepts string action and optional subject
-            expectTypeOf(ability.can).parameter(0).toBeString();
-            expectTypeOf(ability.can).toBeCallableWith('read', 'Post');
-            expectTypeOf(ability.can).toBeCallableWith('read', undefined);
-        });
-    });
-    describe('Builder Function Types', () => {
-        it('should accept sync and async builder functions', () => {
-            const syncBuilder = () => defaultAbilityBuilder();
-            const asyncBuilder = async () => defaultAbilityBuilder();
-            // Both should be valid builder functions
-            expectTypeOf(syncBuilder).toBeFunction();
-            expectTypeOf(asyncBuilder).toBeFunction();
-            expectTypeOf(asyncBuilder).returns.resolves.toEqualTypeOf();
-        });
-        it('should enforce correct parameter types for builders', () => {
-            const builder = user => {
-                expectTypeOf(user).toEqualTypeOf();
-                return defaultAbilityBuilder(user);
-            };
-            expectTypeOf(builder).toBeCallableWith(undefined);
-            expectTypeOf(builder).toBeCallableWith({ id: '1', roles: [] });
-        });
-    });
-});

package/dist/tests/user-roles.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=user-roles.test.d.ts.map

package/dist/tests/user-roles.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"user-roles.test.d.ts","sourceRoot":"","sources":["../../tests/user-roles.test.ts"],"names":[],"mappings":""}

package/dist/tests/user-roles.test.js

@@ -1,157 +0,0 @@
-import { PureAbility, AbilityBuilder } from '@casl/ability';
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { createCaslMiddleware } from '../src/middleware/graphql';
-const Ability = PureAbility;
-// Helper to create abilities with proper matchers
-const createTestAbility = (rules) => {
-    const { can, cannot, build } = new AbilityBuilder(Ability);
-    rules.forEach(rule => {
-        if (rule.inverted) {
-            if (rule.fields && rule.conditions) {
-                cannot(rule.action, rule.subject, rule.fields, rule.conditions);
-            }
-            else if (rule.fields) {
-                cannot(rule.action, rule.subject, rule.fields);
-            }
-            else if (rule.conditions) {
-                cannot(rule.action, rule.subject, rule.conditions);
-            }
-            else {
-                cannot(rule.action, rule.subject);
-            }
-        }
-        else {
-            if (rule.fields && rule.conditions) {
-                can(rule.action, rule.subject, rule.fields, rule.conditions);
-            }
-            else if (rule.fields) {
-                can(rule.action, rule.subject, rule.fields);
-            }
-            else if (rule.conditions) {
-                can(rule.action, rule.subject, rule.conditions);
-            }
-            else {
-                can(rule.action, rule.subject);
-            }
-        }
-    });
-    return build({
-        detectSubjectType: (object) => {
-            // Handle CASL's subject() helper objects
-            if (object && typeof object === 'object') {
-                // CASL uses __caslSubjectType__ property
-                if ('__caslSubjectType__' in object) {
-                    return object.__caslSubjectType__;
-                }
-                // Fallback to other type indicators
-                if (object.type)
-                    return object.type;
-                if (object.constructor?.name && object.constructor.name !== 'Object') {
-                    return object.constructor.name;
-                }
-            }
-            return 'Unknown';
-        },
-        fieldMatcher: fields => field => {
-            if (!fields || !field)
-                return false;
-            return Array.isArray(fields) ? fields.includes(field) : fields === field;
-        },
-        conditionsMatcher: conditions => object => {
-            if (!conditions || !object)
-                return true;
-            return Object.keys(conditions).every(key => object[key] === conditions[key]);
-        },
-    });
-};
-describe('CASL GraphQL Middleware', () => {
-    let mockResolve;
-    let mockContext;
-    let mockInfo;
-    beforeEach(() => {
-        mockResolve = vi.fn().mockResolvedValue({ data: 'test' });
-        mockContext = {
-            ability: createTestAbility([
-                { action: 'read', subject: 'Query' },
-                { action: 'read', subject: 'User' },
-                { action: 'update', subject: 'User', conditions: { id: '123' } },
-            ]),
-            user: { id: '123', roles: ['user'] },
-        };
-        mockInfo = {
-            fieldName: 'getUser',
-            parentType: { name: 'Query' },
-            path: { typename: 'Query', key: 'getUser' },
-            operation: {
-                operation: 'query',
-                loc: { source: { body: 'query { getUser { id } }' } },
-            },
-        };
-    });
-    describe('Basic Middleware Functionality', () => {
-        it('should pass through when ability allows the operation', async () => {
-            const middleware = createCaslMiddleware();
-            // Don't pass args that would be treated as conditions
-            const result = await middleware(mockResolve, {}, {}, mockContext, mockInfo);
-            expect(mockResolve).toHaveBeenCalled();
-            expect(result).toEqual({ data: 'test' });
-        });
-        it('should create ability when not in context', async () => {
-            const middleware = createCaslMiddleware();
-            const contextWithoutAbility = { user: { id: '123', roles: ['user'] } };
-            // The middleware creates a default ability if none exists
-            // Default ability only allows 'read' on 'Query'
-            const result = await middleware(mockResolve, {}, {}, contextWithoutAbility, mockInfo);
-            // Should work because default ability allows 'read' on 'Query'
-            expect(mockResolve).toHaveBeenCalled();
-            expect(result).toEqual({ data: 'test' });
-            expect(contextWithoutAbility.ability).toBeDefined();
-        });
-        it('should deny access when ability does not allow operation', async () => {
-            const middleware = createCaslMiddleware();
-            // Create ability that doesn't allow 'read' on 'Query'
-            mockContext.ability = createTestAbility([{ action: 'read', subject: 'Post' }]);
-            await expect(middleware(mockResolve, {}, {}, mockContext, mockInfo)).rejects.toThrow('Access denied for read on Query');
-        });
-    });
-    describe('Action Mapping', () => {
-        it('should map GraphQL operations to custom actions', async () => {
-            const middleware = createCaslMiddleware({
-                actionMap: {
-                    query: 'view',
-                    mutation: 'modify',
-                    subscription: 'watch',
-                },
-            });
-            // Update ability to allow 'view' instead of 'read'
-            mockContext.ability = createTestAbility([{ action: 'view', subject: 'Query' }]);
-            const result = await middleware(mockResolve, {}, {}, mockContext, mockInfo);
-            expect(mockResolve).toHaveBeenCalled();
-            expect(result).toEqual({ data: 'test' });
-        });
-        it('should deny when custom action is not allowed', async () => {
-            const middleware = createCaslMiddleware({
-                actionMap: {
-                    query: 'view',
-                },
-            });
-            // Ability still has 'read' permission, not 'view'
-            await expect(middleware(mockResolve, {}, {}, mockContext, mockInfo)).rejects.toThrow('Access denied for view on Query');
-        });
-    });
-    describe('Subject Conditions', () => {
-        it('should handle conditional permissions correctly', async () => {
-            const middleware = createCaslMiddleware();
-            // Change to User type which has conditional permission
-            mockInfo.parentType = { name: 'User' };
-            mockInfo.path = { typename: 'User', key: 'updateUser' };
-            mockInfo.operation.operation = 'mutation';
-            // Ability allows update on User with id: '123'
-            mockContext.ability = createTestAbility([{ action: 'update', subject: 'User', conditions: { id: '123' } }]);
-            // This should work because we're not passing the conditions through args
-            // The middleware should check the general permission
-            const result = await middleware(mockResolve, {}, {}, mockContext, mockInfo);
-            expect(mockResolve).toHaveBeenCalled();
-        });
-    });
-});

package/dist/tests/yoga-plugin.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=yoga-plugin.test.d.ts.map

package/dist/tests/yoga-plugin.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"yoga-plugin.test.d.ts","sourceRoot":"","sources":["../../tests/yoga-plugin.test.ts"],"names":[],"mappings":""}