mutts 1.0.0

package/src/promiseChain.test.ts

@@ -0,0 +1,201 @@
+import { chainPromise } from './promiseChain'
+
+describe('chain', () => {
+	describe('basic functionality', () => {
+		it('should return non-promise values as-is', () => {
+			const value = { name: 'test', value: 42 }
+			const result = chainPromise(value)
+			expect(result).toEqual(value)
+		})
+
+		it('should chain method calls on resolved promise values', async () => {
+			const obj = {
+				getName: () => 'John',
+				getAge: () => 30,
+				getInfo: () => ({ name: 'John', age: 30 }),
+			}
+			const promise = Promise.resolve(obj)
+
+			const result = await chainPromise(promise).getName()
+			expect(result).toBe('John')
+		})
+
+		it('should support multiple method chaining', async () => {
+			const obj = {
+				getName: () => 'John',
+				getAge: () => 30,
+				getInfo: () => ({ name: 'John', age: 30 }),
+			}
+			const promise = Promise.resolve(obj)
+
+			const result = await chainPromise(promise).getInfo().name
+			expect(result).toBe('John')
+		})
+
+		it('should handle async methods', async () => {
+			const obj = {
+				getName: async () => 'John',
+				getAge: async () => 30,
+			}
+			const promise = Promise.resolve(obj)
+
+			//const result = await chainPromise(promise).getName()
+			const chained = chainPromise(promise)
+			const getName = chained.getName
+			const result = await getName()
+			expect(result).toBe('John')
+		})
+
+		it('should handle methods with parameters', async () => {
+			const obj = {
+				add: (a: number, b: number) => a + b,
+				multiply: (a: number, b: number) => a * b,
+			}
+			const promise = Promise.resolve(obj)
+
+			const result = await chainPromise(promise).add(5, 3)
+			expect(result).toBe(8)
+		})
+	})
+
+	describe('function calls', () => {
+		it('should allow calling the resolved value as a function', async () => {
+			const func = (name: string, age: number) => `${name} is ${age} years old`
+			const promise = Promise.resolve(func)
+
+			const result = await (chainPromise(promise) as any)('John', 30)
+			expect(result).toBe('John is 30 years old')
+		})
+
+		it('should handle async functions', async () => {
+			const asyncFunc = async (name: string) => `Hello ${name}`
+			const promise = Promise.resolve(asyncFunc)
+
+			const result = await (chainPromise(promise) as any)('World')
+			expect(result).toBe('Hello World')
+		})
+	})
+	/*
+	describe('caching behavior', () => {
+		it('should return the same proxy for the same promise', () => {
+			const promise = Promise.resolve({ test: () => 'value' })
+			const chain1 = chainPromise(promise)
+			const chain2 = chainPromise(promise)
+			
+			expect(chain1).toBe(chain2)
+		})
+
+		it('should not cache different promises', async () => {
+			const promise1 = Promise.resolve({ test: () => 'value1' })
+			const promise2 = Promise.resolve({ test: () => 'value2' })
+			const chain1 = chainPromise(promise1)
+			const chain2 = chainPromise(promise2)
+			
+			expect(chain1).not.toBe(chain2)
+			expect(await chain1).not.toBe(await chain2)
+		})
+	})*/
+
+	describe('complex scenarios', () => {
+		it('should handle nested object methods', async () => {
+			const obj = {
+				user: {
+					getName: () => 'John',
+					getProfile: () => ({
+						age: 30,
+						email: 'john@example.com',
+					}),
+				},
+			}
+			const promise = Promise.resolve(obj)
+
+			const result = await chainPromise(promise).user.getProfile().email
+			expect(result).toBe('john@example.com')
+		})
+
+		it('should handle array methods', async () => {
+			const arr = [1, 2, 3, 4, 5]
+			const promise = Promise.resolve(arr)
+
+			//const result = await chainPromise(promise).filter(x => x > 2).map(x => x * 2)
+
+			const chained = chainPromise(promise)
+			const filtered = chained.filter((x) => {
+				return x > 2
+			})
+			const result = filtered.map((x) => {
+				return x * 2
+			})
+			const awaitResult = await result
+			expect(awaitResult).toEqual([6, 8, 10])
+		})
+
+		it('should handle methods that return promises', async () => {
+			const obj = {
+				getData: () => Promise.resolve({ id: 1, name: 'test' }),
+				processData: (data: any) => Promise.resolve({ ...data, processed: true }),
+			}
+			const promise = Promise.resolve(obj)
+
+			const result = await chainPromise(promise).getData().name
+			expect(result).toBe('test')
+		})
+
+		it('should handle methods that return promises recursively', async () => {
+			const obj = {
+				getData: () => Promise.resolve({ id: 1, name: 'test' }),
+				processData: (data: any) => Promise.resolve({ ...data, processed: true }),
+			}
+
+			//const result = await chainPromise(obj).getData().name
+			const chain = chainPromise(obj)
+			const getData = chain.getData
+			const data = getData()
+			const result = await data.name
+			expect(result).toBe('test')
+		})
+	})
+
+	describe('error handling', () => {
+		it('should handle methods that throw errors', async () => {
+			const obj = {
+				errorMethod: () => {
+					throw new Error('Method error')
+				},
+			}
+			const promise = Promise.resolve(obj)
+
+			await expect(chainPromise(promise).errorMethod()).rejects.toThrow('Method error')
+		})
+	})
+
+	describe('edge cases', () => {
+		it('should handle null and undefined values', () => {
+			expect(chainPromise(null)).toBeNull()
+			expect(chainPromise(undefined)).toBeUndefined()
+		})
+
+		it('should handle primitive values', () => {
+			expect(chainPromise(42)).toBe(42)
+			expect(chainPromise('string')).toBe('string')
+			expect(chainPromise(true)).toBe(true)
+		})
+
+		it('should handle objects without methods', async () => {
+			const obj = { name: 'test', value: 42 }
+			const promise = Promise.resolve(obj)
+
+			const result = await chainPromise(promise).name
+			expect(result).toBe('test')
+		})
+
+		it('should handle symbols as property names', async () => {
+			const sym = Symbol('test')
+			const obj = { [sym]: () => 'symbol value' }
+			const promise = Promise.resolve(obj)
+
+			const result = await chainPromise(promise)[sym]()
+			expect(result).toBe('symbol value')
+		})
+	})
+})

package/src/promiseChain.ts

@@ -0,0 +1,99 @@
+type Resolved<T> = T extends Promise<infer U>
+	? Resolved<U>
+	: T extends (...args: infer Args) => infer R
+		? (...args: Args) => Resolved<R>
+		: T extends object
+			? {
+					[k in keyof T]: k extends 'then' | 'catch' | 'finally' ? T[k] : Resolved<T[k]>
+				}
+			: T
+type PromiseAnd<T> = Resolved<T> & Promise<Resolved<T>>
+export type PromiseChain<T> = T extends (...args: infer Args) => infer R
+	? PromiseAnd<(...args: Args) => PromiseChain<Resolved<R>>>
+	: T extends object
+		? PromiseAnd<{
+				[k in keyof T]: k extends 'then' | 'catch' | 'finally' ? T[k] : PromiseChain<Resolved<T[k]>>
+			}>
+		: Promise<Resolved<T>>
+
+const forward =
+	(name: string, target: any) =>
+	(...args: any[]) => {
+		return target[name](...args)
+	}
+
+const alreadyChained = new WeakMap<any, PromiseChain<any>>()
+const originals = new WeakMap<Promise<any>, any>()
+
+function cache(target: any, rv: PromiseChain<any>) {
+	originals.set(rv, target)
+	alreadyChained.set(target, rv)
+}
+
+type ChainedFunction<T> = ((...args: any[]) => PromiseChain<T>) & {
+	then: Promise<T>['then']
+	catch: Promise<T>['catch']
+	finally: Promise<T>['finally']
+}
+
+const promiseProxyHandler: ProxyHandler<ChainedFunction<any>> = {
+	//@ts-expect-error
+	[Symbol.toStringTag]: 'MutTs PromiseChain function',
+	get(target, prop) {
+		if (prop === Symbol.toStringTag) return 'PromiseProxy'
+		if (typeof prop === 'string' && ['then', 'catch', 'finally'].includes(prop))
+			return target[prop as keyof typeof target]
+		return chainPromise(target.then((r) => r[prop as keyof typeof r]))
+	},
+}
+const promiseForward = (target: any) => ({
+	// biome-ignore lint/suspicious/noThenProperty: This one is the whole point
+	then: forward('then', target),
+	catch: forward('catch', target),
+	finally: forward('finally', target),
+})
+const objectProxyHandler: ProxyHandler<any> = {
+	//@ts-expect-error
+	[Symbol.toStringTag]: 'MutTs PromiseChain object',
+	get(target, prop, receiver) {
+		const getter = Object.getOwnPropertyDescriptor(target, prop)?.get
+		const rv = getter ? getter.call(receiver) : target[prop]
+		// Allows fct.call or fct.apply to bypass the chain system
+		if (typeof target === 'function') return rv
+		return chainPromise(rv)
+	},
+	apply(target, thisArg, args) {
+		return chainPromise(target.apply(thisArg, args))
+	},
+}
+function chainObject<T extends object | Function>(given: T): PromiseChain<T> {
+	const rv = new Proxy(given, objectProxyHandler) as PromiseChain<T>
+	cache(given, rv)
+	return rv
+}
+
+function chainable(x: any): x is object | Function {
+	return x && ['function', 'object'].includes(typeof x)
+}
+export function chainPromise<T>(given: Promise<T> | T): PromiseChain<T> {
+	if (!chainable(given)) return given as PromiseChain<T>
+	if (alreadyChained.has(given)) return alreadyChained.get(given) as PromiseChain<T>
+	if (!(given instanceof Promise)) return chainObject(given)
+	// @ts-expect-error It's ok as we check if it's an object above
+	given = given.then((r) => (chainable(r) ? chainObject(r) : r))
+	const target = Object.assign(function (this: any, ...args: any[]) {
+		return chainPromise(
+			given.then((r) => {
+				return this?.then
+					? this.then((t: any) => (r as any).apply(t, args))
+					: (r as any).apply(this, args)
+			})
+		)
+	}, promiseForward(given)) as ChainedFunction<T>
+	const chained = new Proxy(
+		target,
+		promiseProxyHandler as ProxyHandler<ChainedFunction<T>>
+	) as PromiseChain<T>
+	cache(given, chained as PromiseChain<any>)
+	return chained
+}