urql-computed-exchange-plus 1.0.3

package/.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*]
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+indent_style = space
+indent_size = 2

package/.eslintrc.js

@@ -0,0 +1,58 @@
+module.exports = {
+  parser: '@typescript-eslint/parser',
+  plugins: ['@typescript-eslint', 'jest'],
+  extends: [
+    'eslint:recommended',
+    '@typescript-eslint/recommended',
+    'plugin:jest/recommended'
+  ],
+  parserOptions: {
+    ecmaVersion: 2020,
+    sourceType: 'module',
+    project: './tsconfig.json',
+  },
+  env: {
+    node: true,
+    commonjs: true,
+    browser: true,
+    es6: true,
+    jest: true,
+  },
+  rules: {
+    // General
+    'array-callback-return': ['warn'],
+    'eqeqeq': ['warn', 'always', { null: 'ignore' }],
+    'new-parens': ['warn'],
+    'no-array-constructor': ['warn'],
+    'no-caller': ['warn'],
+    'no-cond-assign': ['warn', 'always'],
+    'no-console': ['warn', { allow: ['warn', 'error'] }],
+    'no-eval': ['warn'],
+    'no-extend-native': ['warn'],
+    'no-extra-bind': ['warn'],
+    'no-implied-eval': ['warn'],
+    'no-iterator': ['warn'],
+    'no-lone-blocks': ['warn'],
+    'no-loop-func': ['warn'],
+    'no-multi-str': ['warn'],
+    'no-new-wrappers': ['warn'],
+    'no-script-url': ['warn'],
+    'no-self-compare': ['warn'],
+    'no-shadow-restricted-names': ['warn'],
+    'no-template-curly-in-string': ['warn'],
+    'no-throw-literal': ['warn'],
+    'no-useless-computed-key': ['warn'],
+    'no-useless-concat': ['warn'],
+    'no-useless-rename': ['warn'],
+    'no-whitespace-before-property': ['warn'],
+
+    // TypeScript
+    'no-unused-vars': 'off',
+    '@typescript-eslint/no-unused-vars': ['warn', { ignoreRestSiblings: true }],
+    'no-useless-constructor': 'off',
+    '@typescript-eslint/no-useless-constructor': ['warn'],
+    '@typescript-eslint/explicit-function-return-type': 'off',
+    '@typescript-eslint/explicit-module-boundary-types': 'off',
+    '@typescript-eslint/no-explicit-any': 'warn',
+  },
+};

package/.importsortrc

@@ -0,0 +1,6 @@
+{
+  ".ts, .tsx": {
+    "parser": "typescript",
+    "style": "module"
+  }
+}

package/.prettierrc

@@ -0,0 +1,12 @@
+{
+  "printWidth": 100,
+  "tabWidth": 2,
+  "useTabs": false,
+  "semi": true,
+  "singleQuote": true,
+  "trailingComma": "all",
+  "bracketSpacing": true,
+  "jsxBracketSameLine": true,
+  "fluid": false,
+  "arrowParens": "always"
+}

package/CHANGELOG.md

@@ -0,0 +1,50 @@
+# Changelog
+
+## [1.0.3] - 2025-01-02
+
+### Fixed
+- **CRITICAL**: Fixed infinite loop in dependency resolution caused by incorrect set difference implementation
+- Fixed circular dependency detection in GraphQL fragment processing
+- Improved error handling for resolver failures (now fails gracefully instead of crashing)
+- Updated integration with latest urql version (removed deprecated `dedupExchange`)
+
+### Added
+- **Async Computed Properties**: Support for async resolvers with caching and TTL
+- **Enhanced TypeScript Types**: Better type safety with generic entity definitions
+- **Circular Dependency Detection**: Proactive detection with detailed error messages
+- **Performance Optimizations**: Handles 1000+ items efficiently with proper caching
+- **Modern Entity Creator**: `createModernEntity` with enhanced type safety
+- **Comprehensive Documentation**: 
+  - Integration examples with different urql exchanges
+  - Dependency resolution behavior explanation
+  - Troubleshooting guide for common issues
+  - Error handling examples
+- **Enhanced Testing**:
+  - Comprehensive integration tests with urql's cache exchange
+  - Performance tests for large datasets
+  - Tests for complex computed property chains
+  - Tests for error handling scenarios
+  - Tests for array handling with computed properties
+  - Async computed property tests
+- **CI/CD Pipeline**: GitHub Actions workflow for automated testing and publishing
+
+### Improved
+- **Better Error Messages**: Detailed error messages for circular dependencies and resolution failures
+- **More Robust Handling**: Better handling of missing dependencies and edge cases
+- **Enhanced TypeScript Support**: Improved type definitions and generic constraints
+- **Documentation**: Comprehensive README with examples and troubleshooting
+- **Test Coverage**: 45+ tests covering unit, integration, and performance scenarios
+
+### Technical Improvements
+- Maximum iteration limit to prevent infinite loops (100 iterations)
+- Proactive circular dependency detection using graph analysis
+- Enhanced resolver error handling with detailed logging
+- Support for complex dependency chains with proper resolution order
+- Async computed properties with caching and TTL support
+- Modern TypeScript features and better type safety
+
+## [1.0.2] - Previous
+- Maintained fork with updated dependencies
+
+## [1.0.1] - Previous  
+- Initial fork from original urql-computed-exchange

package/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org>

package/README.md

@@ -0,0 +1,367 @@
+# URQL Computed Exchange Plus
+
+An [URQL](https://github.com/FormidableLabs/urql) exchange to compute data using resolvers and entities.
+
+**This is a maintained fork of the original `urql-computed-exchange` with updated dependencies and modern tooling.**
+
+## Installation
+
+```bash
+$ npm i urql-computed-exchange-plus
+```
+
+## Usage
+
+First, create your entities and their resolvers:
+
+```javascript
+// entities.js
+import { createEntity, mergeEntities } from 'urql-computed-exchange-plus';
+
+const Pokemon = createEntity('Pokemon', {
+  numberOfEvolutions: {
+    dependencies: gql`
+      fragment _ on Pokemon {
+        evolutions {
+          id
+        }
+      }
+    `,
+    resolver: (pokemon) => {
+      return (pokemon.evolutions && pokemon.evolutions.length) ?? 0;
+    },
+  },
+});
+
+export default mergeEntities(Pokemon);
+```
+
+Then, add it to the list of exchanges in URQL when setting up the client:
+
+```javascript
+// client.js
+
+import { computedExchange } from 'urql-computed-exchange-plus';
+import {
+  createClient,
+  cacheExchange,
+  fetchExchange,
+} from 'urql';
+
+import entities from './entities';
+
+
+const client = createClient({
+  url: 'https://graphql-pokemon.now.sh/',
+  exchanges: [
+    cacheExchange,
+    computedExchange({ entities }),
+    fetchExchange,
+  ],
+});
+
+export default client;
+```
+
+Finally, use the `@computed` directive when declaring your GraphQL queries. Don't forget to indicate the corresponding `type`:
+
+```javascript
+// App.js
+
+import React from 'react';
+import { useQuery } from 'urql';
+import gql from 'graphql-tag';
+
+const PokemonQuery = gql`
+  query PokemonQuery {
+    pokemon(name: "charmander") {
+      id
+      name
+      numberOfEvolutions @computed(type: Pokemon)
+    }
+  }
+`;
+
+const App = () => {
+  const [ res ] = useQuery({
+    query: PokemonQuery,
+  });
+
+  if (res.fetching) {
+    return 'Loading...';
+  }
+
+  return (
+    <pre>
+      {JSON.stringify(res.data, null, 2)}
+    </pre>
+  );
+};
+
+export default App;
+```
+## Error Handling
+
+The exchange handles various error scenarios gracefully:
+
+### Circular Dependencies
+```typescript
+// This will throw an error instead of hanging
+const entities = {
+  User: createEntity('User', {
+    fieldA: {
+      dependencies: gql`fragment _ on User { fieldB @computed(type: User) }`,
+      resolver: (user) => `A-${user.fieldB}`,
+    },
+    fieldB: {
+      dependencies: gql`fragment _ on User { fieldA @computed(type: User) }`,
+      resolver: (user) => `B-${user.fieldA}`,
+    },
+  }),
+};
+```
+
+### Resolver Errors
+```typescript
+const entities = {
+  User: createEntity('User', {
+    riskyField: {
+      dependencies: gql`fragment _ on User { someField }`,
+      resolver: (user) => {
+        if (!user.someField) {
+          throw new Error('Missing required field');
+        }
+        return user.someField.toUpperCase();
+      },
+    },
+  }),
+};
+// If resolver throws, the field will be undefined instead of crashing the query
+```
+
+### Missing Dependencies
+```typescript
+const entities = {
+  User: createEntity('User', {
+    safeField: {
+      dependencies: gql`fragment _ on User { nonExistentField }`,
+      resolver: (user) => user.nonExistentField || 'fallback value',
+    },
+  }),
+};
+```
+
+## Integration with urql Exchanges
+
+The computed exchange works seamlessly with urql's built-in exchanges:
+
+### Basic Setup
+```typescript
+import { createClient, cacheExchange, fetchExchange } from 'urql';
+import { computedExchange } from 'urql-computed-exchange-plus';
+
+const client = createClient({
+  url: 'https://api.example.com/graphql',
+  exchanges: [
+    cacheExchange,           // Works with caching
+    computedExchange({ entities }),
+    fetchExchange,
+  ],
+});
+```
+
+### With Authentication Exchange
+```typescript
+import { authExchange } from '@urql/exchange-auth';
+
+const client = createClient({
+  url: 'https://api.example.com/graphql',
+  exchanges: [
+    cacheExchange,
+    authExchange({
+      // auth config
+    }),
+    computedExchange({ entities }),
+    fetchExchange,
+  ],
+});
+```
+
+### With Retry Exchange
+```typescript
+import { retryExchange } from '@urql/exchange-retry';
+
+const client = createClient({
+  url: 'https://api.example.com/graphql',
+  exchanges: [
+    cacheExchange,
+    retryExchange({
+      initialDelayMs: 1000,
+      maxDelayMs: 15000,
+      randomDelay: true,
+      maxNumberAttempts: 2,
+    }),
+    computedExchange({ entities }),
+    fetchExchange,
+  ],
+});
+```
+
+## Dependency Resolution Behavior
+
+The computed exchange resolves dependencies in the following order:
+
+1. **Parse Query**: Identifies all `@computed` directives and their types
+2. **Collect Dependencies**: Gathers all required fields from entity definitions
+3. **Resolve Chain**: Processes computed properties in dependency order
+4. **Circular Detection**: Prevents infinite loops with maximum iteration limits
+5. **Error Handling**: Gracefully handles resolver failures
+
+### Dependency Chain Example
+```typescript
+const entities = {
+  User: createEntity('User', {
+    // Level 1: Direct field access
+    fullName: {
+      dependencies: gql`fragment _ on User { firstName lastName }`,
+      resolver: (user) => `${user.firstName} ${user.lastName}`,
+    },
+    // Level 2: Depends on Level 1
+    displayName: {
+      dependencies: gql`fragment _ on User { fullName @computed(type: User) title }`,
+      resolver: (user) => `${user.title} ${user.fullName}`,
+    },
+    // Level 3: Depends on Level 2
+    greeting: {
+      dependencies: gql`fragment _ on User { displayName @computed(type: User) }`,
+      resolver: (user) => `Hello, ${user.displayName}!`,
+    },
+  }),
+};
+```
+
+## Troubleshooting
+
+### Common Issues
+
+#### Issue: "Maximum iterations reached" Error
+**Cause**: Circular dependencies in computed properties
+**Solution**: Check your entity definitions for circular references
+```typescript
+// ❌ Bad: Circular dependency
+const entities = {
+  User: createEntity('User', {
+    fieldA: {
+      dependencies: gql`fragment _ on User { fieldB @computed(type: User) }`,
+      resolver: (user) => user.fieldB,
+    },
+    fieldB: {
+      dependencies: gql`fragment _ on User { fieldA @computed(type: User) }`,
+      resolver: (user) => user.fieldA,
+    },
+  }),
+};
+
+// ✅ Good: Linear dependency chain
+const entities = {
+  User: createEntity('User', {
+    fullName: {
+      dependencies: gql`fragment _ on User { firstName lastName }`,
+      resolver: (user) => `${user.firstName} ${user.lastName}`,
+    },
+    displayName: {
+      dependencies: gql`fragment _ on User { fullName @computed(type: User) title }`,
+      resolver: (user) => `${user.title} ${user.fullName}`,
+    },
+  }),
+};
+```
+
+#### Issue: Computed Fields Return `undefined`
+**Cause**: Missing dependencies or resolver errors
+**Solution**: Check that all required fields are available and resolvers handle edge cases
+```typescript
+// ✅ Good: Handle missing data gracefully
+const entities = {
+  User: createEntity('User', {
+    safeField: {
+      dependencies: gql`fragment _ on User { optionalField }`,
+      resolver: (user) => {
+        if (!user.optionalField) {
+          return 'Default Value';
+        }
+        return user.optionalField.toUpperCase();
+      },
+    },
+  }),
+};
+```
+
+#### Issue: Performance Issues with Large Datasets
+**Cause**: Complex computed property chains on many items
+**Solution**: Optimize resolvers and consider caching
+```typescript
+// ✅ Good: Efficient resolver
+const entities = {
+  User: createEntity('User', {
+    expensiveComputation: {
+      dependencies: gql`fragment _ on User { data }`,
+      resolver: (user) => {
+        // Cache expensive operations
+        if (user._cachedResult) return user._cachedResult;
+        const result = performExpensiveOperation(user.data);
+        user._cachedResult = result;
+        return result;
+      },
+    },
+  }),
+};
+```
+
+#### Issue: TypeScript Type Errors
+**Cause**: Incorrect type annotations or missing type definitions
+**Solution**: Ensure proper typing for entities and resolvers
+```typescript
+interface User {
+  id: string;
+  firstName: string;
+  lastName: string;
+}
+
+const entities = {
+  User: createEntity('User', {
+    fullName: {
+      dependencies: gql`fragment _ on User { firstName lastName }`,
+      resolver: (user: User) => `${user.firstName} ${user.lastName}`,
+    },
+  }),
+};
+```
+
+## Testing
+
+The library includes comprehensive test coverage:
+- Unit tests for core functionality
+- Integration tests with urql's cache exchange  
+- Error handling and edge case testing
+- Performance and circular dependency protection
+
+Run tests:
+```bash
+npm test                           # Unit tests
+npm run test:integration          # Integration tests
+npm run test:performance          # Performance tests
+npm run test:all                  # All tests
+```
+
+## Changelog
+
+See [CHANGELOG.md](./CHANGELOG.md) for version history and breaking changes.
+
+## Contributing
+
+This is a maintained fork. Contributions are welcome! Please ensure tests pass and add tests for new features.
+
+## License
+
+MIT

package/jest.config.js

@@ -0,0 +1,19 @@
+const path = require('path');
+
+module.exports = {
+  preset: 'ts-jest',
+  verbose: false,
+  testEnvironment: 'node',
+  rootDir: path.resolve(__dirname, 'src'),
+  coverageDirectory: './coverage',
+  moduleFileExtensions: ['js', 'json', 'ts'],
+  testRegex: '\\.test\\.ts$',
+  transform: {
+    '^.+\\.(t|j)s$': 'ts-jest',
+  },
+  collectCoverageFrom: [
+    '**/*.(t|j)s',
+    '!**/*.test.(t|j)s',
+    '!**/node_modules/**',
+  ],
+};

package/jest.integration.config.js

@@ -0,0 +1,14 @@
+const path = require('path');
+
+module.exports = {
+  preset: 'ts-jest',
+  verbose: false,
+  testEnvironment: 'node',
+  rootDir: path.resolve(__dirname, 'test'),
+  coverageDirectory: './coverage',
+  moduleFileExtensions: ['js', 'json', 'ts'],
+  testRegex: '\\.test\\.ts$',
+  transform: {
+    '^.+\\.(t|j)s$': 'ts-jest',
+  },
+};

package/jest.performance.config.js

@@ -0,0 +1,19 @@
+const path = require('path');
+
+module.exports = {
+  preset: 'ts-jest',
+  verbose: false,
+  testEnvironment: 'node',
+  rootDir: path.resolve(__dirname),
+  coverageDirectory: './coverage',
+  moduleFileExtensions: ['js', 'json', 'ts'],
+  testRegex: 'test/performance/.*\\.test\\.ts$',
+  transform: {
+    '^.+\\.(t|j)s$': 'ts-jest',
+  },
+  collectCoverageFrom: [
+    'src/**/*.(t|j)s',
+    '!src/**/*.test.(t|j)s',
+    '!**/node_modules/**',
+  ],
+};

package/lib/async-computed.d.ts

@@ -0,0 +1,16 @@
+import { DocumentNode } from 'graphql';
+import { GraphQLObject } from './types';
+export type AsyncComputedResolver<T extends GraphQLObject = GraphQLObject, R = any> = (data: T) => Promise<R>;
+export interface AsyncComputedProperty<T extends GraphQLObject = GraphQLObject, R = any> {
+    dependencies: DocumentNode;
+    resolver: AsyncComputedResolver<T, R>;
+    cacheKey?: (data: T) => string;
+    ttl?: number;
+}
+export declare function resolveAsyncComputedProperties<T extends GraphQLObject>(data: T, properties: Record<string, AsyncComputedProperty<T>>): Promise<Partial<T>>;
+export declare function createAsyncEntity<T extends GraphQLObject = GraphQLObject>(typeName: string, properties: Record<string, AsyncComputedProperty<T>>): {
+    __typename: string;
+    asyncComputedProperties: Record<string, AsyncComputedProperty<T, any>>;
+    resolve: (data: T) => Promise<Partial<T>>;
+};
+export declare function clearAsyncComputedCache(): void;

package/lib/async-computed.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAsyncComputedProperties = resolveAsyncComputedProperties;
+exports.createAsyncEntity = createAsyncEntity;
+exports.clearAsyncComputedCache = clearAsyncComputedCache;
+class AsyncComputedCache {
+    constructor() {
+        this.cache = new Map();
+    }
+    set(key, value, ttl = 5 * 60 * 1000) {
+        this.cache.set(key, {
+            value,
+            timestamp: Date.now(),
+            ttl,
+        });
+    }
+    get(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return undefined;
+        if (Date.now() - entry.timestamp > entry.ttl) {
+            this.cache.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    clear() {
+        this.cache.clear();
+    }
+}
+const asyncCache = new AsyncComputedCache();
+async function resolveAsyncComputedProperties(data, properties) {
+    const results = {};
+    const promises = Object.entries(properties).map(async ([key, property]) => {
+        try {
+            const cacheKey = property.cacheKey
+                ? `${data.__typename}:${key}:${property.cacheKey(data)}`
+                : `${data.__typename}:${key}:${JSON.stringify(data)}`;
+            const cached = asyncCache.get(cacheKey);
+            if (cached !== undefined) {
+                return [key, cached];
+            }
+            const result = await property.resolver(data);
+            asyncCache.set(cacheKey, result, property.ttl);
+            return [key, result];
+        }
+        catch (error) {
+            console.warn(`Async computed property "${key}" failed:`, error);
+            return [key, undefined];
+        }
+    });
+    const resolvedEntries = await Promise.all(promises);
+    for (const [key, value] of resolvedEntries) {
+        results[key] = value;
+    }
+    return results;
+}
+function createAsyncEntity(typeName, properties) {
+    return {
+        __typename: typeName,
+        asyncComputedProperties: properties,
+        resolve: (data) => resolveAsyncComputedProperties(data, properties),
+    };
+}
+function clearAsyncComputedCache() {
+    asyncCache.clear();
+}
+//# sourceMappingURL=async-computed.js.map

package/lib/async-computed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-computed.js","sourceRoot":"","sources":["../src/async-computed.ts"],"names":[],"mappings":"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"}

package/lib/computed-exchange.d.ts

@@ -0,0 +1,5 @@
+import { Exchange } from 'urql';
+import { Entities } from './types';
+export declare function computedExchange({ entities }: {
+    entities: Entities;
+}): Exchange;