@adobe/data 0.9.7 → 0.9.16

package/service/async-data-service/create-lazy.js

@@ -0,0 +1,194 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+// ============================================================================
+// MAIN FUNCTION SIGNATURE
+// ============================================================================
+/**
+ * Creates a lazy-loading wrapper factory for an AsyncDataService.
+ * The real service is only loaded when the first property is accessed.
+ * All calls are queued and executed in order once the service loads.
+ *
+ * @param load - Function that loads and returns the real service (may accept args)
+ * @param properties - Object describing how to wrap each service property
+ * @returns A factory function that creates lazy service instances
+ *
+ * TypeScript will enforce:
+ * - All service properties must be declared in properties object
+ * - Each descriptor must match the actual property type
+ * - Clear errors indicate what is missing or wrong
+ *
+ * @example
+ * ```typescript
+ * // Service with no args
+ * const createLazySimple = createLazy(
+ *   () => import('./simple').then(m => m.create()),
+ *   { data: 'observe', fetch: 'fn:promise' }
+ * );
+ * const service = createLazySimple();
+ *
+ * // Service with args
+ * const createLazyConfig = createLazy(
+ *   (config: Config) => import('./service').then(m => m.create(config)),
+ *   { data: 'observe', fetch: 'fn:promise' }
+ * );
+ * const service = createLazyConfig({ apiUrl: '...' });
+ * ```
+ */
+export function createLazy(load, properties) {
+    // Return factory function that creates lazy service instances
+    return ((...factoryArgs) => {
+        // Shared loading state for this instance
+        let loadPromise = null;
+        let loadedService = null;
+        const ensureLoading = () => {
+            if (loadedService) {
+                return Promise.resolve(loadedService);
+            }
+            if (loadPromise) {
+                return loadPromise;
+            }
+            loadPromise = load(...factoryArgs).then((service) => {
+                loadedService = service;
+                return service;
+            });
+            return loadPromise;
+        };
+        // Build lazy service object
+        const lazyService = {
+            serviceName: 'lazy-service',
+        };
+        // Wrap each property based on its descriptor
+        for (const [key, descriptor] of Object.entries(properties)) {
+            if (descriptor === 'observe') {
+                // Observe property - defer subscription until service loads
+                lazyService[key] = (notify) => {
+                    let unobserveReal = null;
+                    let isCancelled = false;
+                    ensureLoading().then((service) => {
+                        if (!isCancelled && service.serviceName !== 'lazy-service') {
+                            // Update lazy service name once real service loads
+                            lazyService.serviceName = `lazy-${service.serviceName}`;
+                        }
+                        if (!isCancelled) {
+                            unobserveReal = service[key](notify);
+                        }
+                    });
+                    return () => {
+                        isCancelled = true;
+                        unobserveReal?.();
+                    };
+                };
+            }
+            else if (descriptor === 'fn:promise') {
+                const queue = [];
+                let isProcessing = false;
+                lazyService[key] = (...args) => {
+                    return new Promise((resolve, reject) => {
+                        queue.push({ args, resolve, reject });
+                        if (!isProcessing) {
+                            isProcessing = true;
+                            ensureLoading().then(async (service) => {
+                                if (service.serviceName !== 'lazy-service') {
+                                    lazyService.serviceName = `lazy-${service.serviceName}`;
+                                }
+                                // Execute all queued calls in order
+                                while (queue.length > 0) {
+                                    const call = queue.shift();
+                                    try {
+                                        const result = await service[key](...call.args);
+                                        call.resolve(result);
+                                    }
+                                    catch (error) {
+                                        call.reject(error);
+                                    }
+                                }
+                            }).catch(error => {
+                                // Service load failed, reject all queued calls
+                                while (queue.length > 0) {
+                                    queue.shift().reject(error);
+                                }
+                            });
+                        }
+                    });
+                };
+            }
+            else if (descriptor === 'fn:void') {
+                // Void function - queue calls and execute after load
+                const queue = [];
+                let isProcessing = false;
+                lazyService[key] = (...args) => {
+                    queue.push(args);
+                    if (!isProcessing) {
+                        isProcessing = true;
+                        ensureLoading().then((service) => {
+                            if (service.serviceName !== 'lazy-service') {
+                                lazyService.serviceName = `lazy-${service.serviceName}`;
+                            }
+                            // Execute all queued calls in order
+                            while (queue.length > 0) {
+                                const args = queue.shift();
+                                service[key](...args);
+                            }
+                        });
+                    }
+                };
+            }
+            else if (descriptor === 'fn:observe') {
+                // Observe function - returns Observe that waits for service
+                lazyService[key] = (...args) => {
+                    return (notify) => {
+                        let unobserveReal = null;
+                        let isCancelled = false;
+                        ensureLoading().then((service) => {
+                            if (service.serviceName !== 'lazy-service') {
+                                lazyService.serviceName = `lazy-${service.serviceName}`;
+                            }
+                            if (!isCancelled) {
+                                const realObserve = service[key](...args);
+                                unobserveReal = realObserve(notify);
+                            }
+                        });
+                        return () => {
+                            isCancelled = true;
+                            unobserveReal?.();
+                        };
+                    };
+                };
+            }
+            else if (descriptor === 'fn:generator') {
+                // AsyncGenerator function - returns generator that waits for service
+                lazyService[key] = (...args) => {
+                    let realGenerator = null;
+                    return {
+                        async next() {
+                            if (!realGenerator) {
+                                const service = await ensureLoading();
+                                if (service.serviceName !== 'lazy-service') {
+                                    lazyService.serviceName = `lazy-${service.serviceName}`;
+                                }
+                                realGenerator = service[key](...args);
+                            }
+                            return realGenerator.next();
+                        },
+                        async return(value) {
+                            if (realGenerator) {
+                                return realGenerator.return(value);
+                            }
+                            return { done: true, value: value };
+                        },
+                        async throw(e) {
+                            if (realGenerator) {
+                                return realGenerator.throw(e);
+                            }
+                            throw e;
+                        },
+                        [Symbol.asyncIterator]() {
+                            return this;
+                        }
+                    };
+                };
+            }
+        }
+        return lazyService;
+    });
+}
+//# sourceMappingURL=create-lazy.js.map

package/service/async-data-service/create-lazy.js.map

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

package/service/async-data-service/create-lazy.test.js

@@ -0,0 +1,477 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, test } from 'vitest';
+import { assert } from 'riteway/vitest';
+import { createLazy } from "./create-lazy.js";
+// ============================================================================
+// VALID USAGE TESTS
+// ============================================================================
+// ✅ Test 1: Complete descriptor for SimpleAuthService
+const validAuth = createLazy(() => Promise.resolve({}), {
+    isSignedIn: 'observe',
+    accessToken: 'observe',
+    userProfile: 'observe',
+    showSignInDialog: 'fn:void',
+    hideSignInDialog: 'fn:void',
+    refreshToken: 'fn:promise',
+    signIn: 'fn:promise',
+    signOut: 'fn:promise'
+});
+// ✅ Test 2: Service with function returning Observe
+const validObserveFn = createLazy(() => Promise.resolve({}), {
+    allUsers: 'observe',
+    selectUser: 'fn:observe',
+    fetchData: 'fn:promise'
+});
+// ✅ Test 3: Service with AsyncGenerator
+const validGenerator = createLazy(() => Promise.resolve({}), {
+    status: 'observe',
+    streamEvents: 'fn:generator',
+    cancel: 'fn:void'
+});
+const validWithArgs = createLazy((args) => {
+    // args is properly typed as ServiceConfig
+    console.log(args.apiUrl);
+    return Promise.resolve({});
+}, {
+    config: 'observe',
+    fetch: 'fn:promise'
+});
+// ============================================================================
+// ERROR TESTS (These should produce TypeScript errors)
+// ============================================================================
+// ❌ Test 5: Missing property 'refreshToken'
+const errorMissing = createLazy(() => Promise.resolve({}), 
+// @ts-expect-error - Missing property 'refreshToken' in descriptor
+{
+    isSignedIn: 'observe',
+    accessToken: 'observe',
+    userProfile: 'observe',
+    showSignInDialog: 'fn:void',
+    hideSignInDialog: 'fn:void',
+    // Missing: refreshToken
+    signIn: 'fn:promise',
+    signOut: 'fn:promise'
+});
+// ❌ Test 6: Wrong descriptor type (observe property marked as fn:observe)
+const errorWrongType1 = createLazy(() => Promise.resolve({}), {
+    // @ts-expect-error - Wrong descriptor type
+    isSignedIn: 'fn:observe', // WRONG: should be 'observe'
+    accessToken: 'observe',
+    userProfile: 'observe',
+    showSignInDialog: 'fn:void',
+    hideSignInDialog: 'fn:void',
+    refreshToken: 'fn:promise',
+    signIn: 'fn:promise',
+    signOut: 'fn:promise'
+});
+// ❌ Test 7: Wrong descriptor type (void function marked as fn:promise)
+const errorWrongType2 = createLazy(() => Promise.resolve({}), {
+    isSignedIn: 'observe',
+    accessToken: 'observe',
+    userProfile: 'observe',
+    // @ts-expect-error - Wrong descriptor type
+    showSignInDialog: 'fn:promise', // WRONG: should be 'fn:void'
+    hideSignInDialog: 'fn:void',
+    refreshToken: 'fn:promise',
+    signIn: 'fn:promise',
+    signOut: 'fn:promise'
+});
+// ❌ Test 8: Extra property that doesn't exist in service
+const errorExtra = createLazy(() => Promise.resolve({}), {
+    allUsers: 'observe',
+    selectUser: 'fn:observe',
+    fetchData: 'fn:promise',
+    // @ts-expect-error - Extra property
+    unknownProperty: 'observe' // EXTRA: doesn't exist in service
+});
+// ❌ Test 9: Wrong descriptor for fn:observe (marked as observe)
+const errorObserveFn = createLazy(() => Promise.resolve({}), {
+    allUsers: 'observe',
+    // @ts-expect-error - Wrong descriptor type
+    selectUser: 'observe', // WRONG: should be 'fn:observe'
+    fetchData: 'fn:promise'
+});
+// ❌ Test 10: Wrong descriptor for generator
+const errorGenerator = createLazy(() => Promise.resolve({}), {
+    status: 'observe',
+    // @ts-expect-error - Wrong descriptor type
+    streamEvents: 'fn:promise', // WRONG: should be 'fn:generator'
+    cancel: 'fn:void'
+});
+// ============================================================================
+// RUNTIME TESTS
+// ============================================================================
+describe('createLazy', () => {
+    test('factory pattern', async () => {
+        const createTestService = () => {
+            return Promise.resolve({
+                serviceName: 'test-service',
+                value: (notify) => {
+                    notify('test-value');
+                    return () => { };
+                }
+            });
+        };
+        const factory = createLazy(createTestService, { value: 'observe' });
+        assert({
+            given: 'createLazy is called',
+            should: 'return a factory function',
+            actual: typeof factory,
+            expected: 'function'
+        });
+        const service = factory();
+        assert({
+            given: 'factory function is called',
+            should: 'return a service with serviceName',
+            actual: typeof service.serviceName,
+            expected: 'string'
+        });
+    });
+    test('observe property', async () => {
+        const createTestService = () => {
+            return Promise.resolve({
+                serviceName: 'test-service',
+                value: (notify) => {
+                    notify('test-value');
+                    return () => { };
+                }
+            });
+        };
+        const factory = createLazy(createTestService, { value: 'observe' });
+        const service = factory();
+        let receivedValue = null;
+        const unobserve = service.value((value) => {
+            receivedValue = value;
+        });
+        // Wait for async load
+        await new Promise(resolve => setTimeout(resolve, 10));
+        assert({
+            given: 'observe property is subscribed',
+            should: 'receive value from real service after load',
+            actual: receivedValue,
+            expected: 'test-value'
+        });
+        unobserve();
+    });
+    test('observe property returns same instance', async () => {
+        const createTestService = () => {
+            return Promise.resolve({
+                serviceName: 'test-service',
+                value: (notify) => {
+                    notify('test-value');
+                    return () => { };
+                }
+            });
+        };
+        const factory = createLazy(createTestService, { value: 'observe' });
+        const service = factory();
+        const observe1 = service.value;
+        const observe2 = service.value;
+        assert({
+            given: 'observe property is accessed multiple times',
+            should: 'return the same Observe instance',
+            actual: observe1 === observe2,
+            expected: true
+        });
+    });
+    test('promise function', async () => {
+        const createTestService = () => {
+            return Promise.resolve({
+                serviceName: 'test-service',
+                fetchData: async (id) => {
+                    return { value: `data-${id}` };
+                }
+            });
+        };
+        const factory = createLazy(createTestService, { fetchData: 'fn:promise' });
+        const service = factory();
+        const result = await service.fetchData('123');
+        assert({
+            given: 'promise function is called',
+            should: 'return result from real service',
+            actual: result.value,
+            expected: 'data-123'
+        });
+    });
+    test('promise function queuing', async () => {
+        const calls = [];
+        const createTestService = () => {
+            return new Promise(resolve => {
+                setTimeout(() => {
+                    resolve({
+                        serviceName: 'test-service',
+                        fetchData: async (id) => {
+                            calls.push(id);
+                            return `result-${id}`;
+                        }
+                    });
+                }, 50);
+            });
+        };
+        const factory = createLazy(createTestService, { fetchData: 'fn:promise' });
+        const service = factory();
+        // Call multiple times before service loads
+        const p1 = service.fetchData('a');
+        const p2 = service.fetchData('b');
+        const p3 = service.fetchData('c');
+        const results = await Promise.all([p1, p2, p3]);
+        assert({
+            given: 'multiple calls made before service loads',
+            should: 'execute all calls in order',
+            actual: calls.join(','),
+            expected: 'a,b,c'
+        });
+        assert({
+            given: 'queued calls complete',
+            should: 'return correct results',
+            actual: results.join(','),
+            expected: 'result-a,result-b,result-c'
+        });
+    });
+    test('promise function returns same instance', async () => {
+        const factory = createLazy(() => Promise.resolve({
+            serviceName: 'test-service',
+            fetchData: async (id) => `result-${id}`
+        }), { fetchData: 'fn:promise' });
+        const service = factory();
+        const fn1 = service.fetchData;
+        const fn2 = service.fetchData;
+        assert({
+            given: 'promise function property is accessed multiple times',
+            should: 'return the same function instance',
+            actual: fn1 === fn2,
+            expected: true
+        });
+    });
+    test('promise function calls return different promises', async () => {
+        const factory = createLazy(() => Promise.resolve({
+            serviceName: 'test-service',
+            fetchData: async (id) => `result-${id}`
+        }), { fetchData: 'fn:promise' });
+        const service = factory();
+        const promise1 = service.fetchData('id-1');
+        const promise2 = service.fetchData('id-1');
+        const promise3 = service.fetchData('id-2');
+        assert({
+            given: 'promise function is called multiple times',
+            should: 'return different Promise instances',
+            actual: promise1 !== promise2 && promise1 !== promise3,
+            expected: true
+        });
+        const results = await Promise.all([promise1, promise2, promise3]);
+        assert({
+            given: 'promise function called with different args',
+            should: 'resolve to correct values independently',
+            actual: results.join(','),
+            expected: 'result-id-1,result-id-1,result-id-2'
+        });
+    });
+    test('void function', async () => {
+        const events = [];
+        const createTestService = () => {
+            return Promise.resolve({
+                serviceName: 'test-service',
+                track: (event) => {
+                    events.push(event);
+                }
+            });
+        };
+        const factory = createLazy(createTestService, { track: 'fn:void' });
+        const service = factory();
+        service.track('event-1');
+        service.track('event-2');
+        // Wait for async load and execution
+        await new Promise(resolve => setTimeout(resolve, 10));
+        assert({
+            given: 'void functions are called',
+            should: 'execute all calls in order after load',
+            actual: events.join(','),
+            expected: 'event-1,event-2'
+        });
+    });
+    test('observe function', async () => {
+        const createTestService = () => {
+            return Promise.resolve({
+                serviceName: 'test-service',
+                selectUser: (id) => (notify) => {
+                    notify(`user-${id}`);
+                    return () => { };
+                }
+            });
+        };
+        const factory = createLazy(createTestService, { selectUser: 'fn:observe' });
+        const service = factory();
+        let receivedValue = null;
+        const observe = service.selectUser('123');
+        const unobserve = observe((value) => {
+            receivedValue = value;
+        });
+        // Wait for async load
+        await new Promise(resolve => setTimeout(resolve, 10));
+        assert({
+            given: 'observe function is called and subscribed',
+            should: 'receive value from real service',
+            actual: receivedValue,
+            expected: 'user-123'
+        });
+        unobserve();
+    });
+    test('observe function returns same instance', async () => {
+        const factory = createLazy(() => Promise.resolve({
+            serviceName: 'test-service',
+            selectUser: (id) => (notify) => {
+                notify(`user-${id}`);
+                return () => { };
+            }
+        }), { selectUser: 'fn:observe' });
+        const service = factory();
+        const fn1 = service.selectUser;
+        const fn2 = service.selectUser;
+        assert({
+            given: 'observe function property is accessed multiple times',
+            should: 'return the same function instance',
+            actual: fn1 === fn2,
+            expected: true
+        });
+    });
+    test('observe function calls return different instances', async () => {
+        const factory = createLazy(() => Promise.resolve({
+            serviceName: 'test-service',
+            selectUser: (id) => (notify) => {
+                notify(`user-${id}`);
+                return () => { };
+            }
+        }), { selectUser: 'fn:observe' });
+        const service = factory();
+        const observe1 = service.selectUser('id-1');
+        const observe2 = service.selectUser('id-1');
+        const observe3 = service.selectUser('id-2');
+        assert({
+            given: 'observe function is called multiple times with same args',
+            should: 'return different Observe instances',
+            actual: observe1 !== observe2,
+            expected: true
+        });
+        assert({
+            given: 'observe function is called with different args',
+            should: 'return different Observe instances',
+            actual: observe1 !== observe3,
+            expected: true
+        });
+    });
+    test('observe function calls with different args work independently', async () => {
+        const factory = createLazy(() => Promise.resolve({
+            serviceName: 'test-service',
+            selectUser: (id) => (notify) => {
+                notify(`user-${id}`);
+                return () => { };
+            }
+        }), { selectUser: 'fn:observe' });
+        const service = factory();
+        const values = [];
+        const observe1 = service.selectUser('id-1');
+        const unobserve1 = observe1((value) => values.push(`obs1:${value}`));
+        const observe2 = service.selectUser('id-2');
+        const unobserve2 = observe2((value) => values.push(`obs2:${value}`));
+        // Wait for async load
+        await new Promise(resolve => setTimeout(resolve, 10));
+        assert({
+            given: 'multiple observe function calls with different args',
+            should: 'each receive their own values independently',
+            actual: values.sort().join(','),
+            expected: 'obs1:user-id-1,obs2:user-id-2'
+        });
+        unobserve1();
+        unobserve2();
+    });
+    test('generator function', async () => {
+        const createTestService = () => {
+            return Promise.resolve({
+                serviceName: 'test-service',
+                streamData: async function* () {
+                    yield 1;
+                    yield 2;
+                    yield 3;
+                }
+            });
+        };
+        const factory = createLazy(createTestService, { streamData: 'fn:generator' });
+        const service = factory();
+        const values = [];
+        for await (const value of service.streamData()) {
+            values.push(value);
+        }
+        assert({
+            given: 'generator function is called',
+            should: 'yield all values from real service',
+            actual: values.join(','),
+            expected: '1,2,3'
+        });
+    });
+    test('generator function returns same instance', async () => {
+        const factory = createLazy(() => Promise.resolve({
+            serviceName: 'test-service',
+            streamData: async function* () {
+                yield 1;
+                yield 2;
+            }
+        }), { streamData: 'fn:generator' });
+        const service = factory();
+        const fn1 = service.streamData;
+        const fn2 = service.streamData;
+        assert({
+            given: 'generator function property is accessed multiple times',
+            should: 'return the same function instance',
+            actual: fn1 === fn2,
+            expected: true
+        });
+    });
+    test('generator function calls return different generators', async () => {
+        const factory = createLazy(() => Promise.resolve({
+            serviceName: 'test-service',
+            streamData: async function* (prefix) {
+                yield `${prefix}-1`;
+                yield `${prefix}-2`;
+            }
+        }), { streamData: 'fn:generator' });
+        const service = factory();
+        const gen1 = service.streamData('A');
+        const gen2 = service.streamData('B');
+        assert({
+            given: 'generator function is called multiple times',
+            should: 'return different AsyncGenerator instances',
+            actual: gen1 !== gen2,
+            expected: true
+        });
+        const values1 = [];
+        const values2 = [];
+        for await (const value of gen1) {
+            values1.push(value);
+        }
+        for await (const value of gen2) {
+            values2.push(value);
+        }
+        assert({
+            given: 'different generator instances with different args',
+            should: 'produce independent sequences',
+            actual: `${values1.join(',')}|${values2.join(',')}`,
+            expected: 'A-1,A-2|B-1,B-2'
+        });
+    });
+    test('void function returns same instance', async () => {
+        const factory = createLazy(() => Promise.resolve({
+            serviceName: 'test-service',
+            track: (event) => { }
+        }), { track: 'fn:void' });
+        const service = factory();
+        const fn1 = service.track;
+        const fn2 = service.track;
+        assert({
+            given: 'void function property is accessed multiple times',
+            should: 'return the same function instance',
+            actual: fn1 === fn2,
+            expected: true
+        });
+    });
+});
+//# sourceMappingURL=create-lazy.test.js.map