@pooflabs/core 0.0.41 → 0.0.42

package/README.md

@@ -39,6 +39,15 @@ export interface User {
   address: string;
   provider: AuthProvider;
 }
+
+export interface GetManyResult {
+  path: string;
+  data: any | null;
+  error?: {
+    code: 'NOT_FOUND' | 'UNAUTHORIZED' | 'INVALID_PATH';
+    message: string;
+  };
+}
 ```
 
 ### Core Operations
@@ -52,6 +61,7 @@ function getConfig(): Promise<ClientConfig>;
 
 // Data operations
 function get(path: string): Promise<any>;
+function getMany(paths: string[], options?: { bypassCache?: boolean }): Promise<GetManyResult[]>;
 function set(path: string, data: any, options?: SetOptions): Promise<any>;
 function setMany(paths: { [key: string]: any }, options?: SetOptions): Promise<any>;
 function setFile(path: string, file: File, metadata?: any): Promise<any>;

package/dist/client/operations.d.ts

@@ -113,6 +113,20 @@ export declare function count(path: string, opts?: CountOptions): Promise<Aggreg
  */
 export declare function aggregate(path: string, operation: AggregateOperation, opts?: AggregateOptions): Promise<AggregateResult>;
 export declare function get(path: string, opts?: GetOptions): Promise<any>;
+export type GetManyResult = {
+    path: string;
+    data: any | null;
+    error?: {
+        code: 'NOT_FOUND' | 'UNAUTHORIZED' | 'INVALID_PATH';
+        message: string;
+    };
+};
+export declare function getMany(paths: string[], opts?: {
+    bypassCache?: boolean;
+    _overrides?: {
+        headers?: Record<string, string>;
+    };
+}): Promise<GetManyResult[]>;
 export type RunExpressionOptions = {
     returnType?: 'Bool' | 'String' | 'Int' | 'UInt';
     _overrides?: RequestOverrides;

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { init } from './client/config';
 export { getConfig, ClientConfig } from './client/config';
-export { get, set, setMany, setFile, getFiles, runQuery, runQueryMany, runExpression, runExpressionMany, signMessage, signTransaction, signAndSubmitTransaction, count, aggregate, RequestOverrides, SetOptions, GetOptions, RunQueryOptions, CountOptions, AggregateOptions, AggregateOperation, AggregateResult, RunExpressionOptions, RunExpressionResult, InsufficientBalanceError } from './client/operations';
+export { get, getMany, set, setMany, setFile, getFiles, runQuery, runQueryMany, runExpression, runExpressionMany, signMessage, signTransaction, signAndSubmitTransaction, count, aggregate, RequestOverrides, SetOptions, GetOptions, RunQueryOptions, CountOptions, AggregateOptions, AggregateOperation, AggregateResult, RunExpressionOptions, RunExpressionResult, InsufficientBalanceError, GetManyResult } from './client/operations';
 export { subscribe, closeAllSubscriptions, clearCache, getCachedData, reconnectWithNewAuth } from './client/subscription';
 export * from './types';
 export { getIdToken } from './utils/utils';

package/dist/index.js

@@ -3748,6 +3748,90 @@ function cleanupExpiredCache() {
     });
     lastCacheCleanup = now;
 }
+async function getMany(paths, opts = {}) {
+    if (paths.length === 0) {
+        return [];
+    }
+    if (paths.length > 30) {
+        throw new Error('Cannot fetch more than 30 documents at once');
+    }
+    const normalizedPaths = [];
+    for (const path of paths) {
+        let normalizedPath = path.startsWith("/") ? path.slice(1) : path;
+        if (normalizedPath.endsWith("*") && normalizedPath.length > 1) {
+            normalizedPath = normalizedPath.slice(0, -1);
+        }
+        if (!normalizedPath || normalizedPath.length === 0) {
+            throw new Error(`Invalid path provided: ${path}`);
+        }
+        const pathIsDocument = normalizedPath.split("/").length % 2 === 0;
+        if (!pathIsDocument) {
+            throw new Error(`Path must point to a document (even number of segments): ${path}`);
+        }
+        normalizedPaths.push(normalizedPath);
+    }
+    const now = Date.now();
+    const results = new Array(paths.length);
+    const uncachedIndices = [];
+    const uncachedPaths = [];
+    for (let i = 0; i < normalizedPaths.length; i++) {
+        const normalizedPath = normalizedPaths[i];
+        const cacheKey = `${normalizedPath}:`;
+        if (!opts.bypassCache && getCache[cacheKey] && now < getCache[cacheKey].expiresAt) {
+            results[i] = { path: normalizedPath, data: getCache[cacheKey].data };
+        }
+        else {
+            uncachedIndices.push(i);
+            uncachedPaths.push(normalizedPath);
+        }
+    }
+    if (uncachedPaths.length > 0) {
+        try {
+            const response = await makeApiRequest('POST', 'items/batch', { paths: uncachedPaths }, opts._overrides);
+            const serverResults = response.data.results;
+            const serverResultsMap = new Map();
+            for (const result of serverResults) {
+                serverResultsMap.set(result.path, result);
+            }
+            for (let i = 0; i < uncachedIndices.length; i++) {
+                const originalIndex = uncachedIndices[i];
+                const normalizedPath = uncachedPaths[i];
+                const serverResult = serverResultsMap.get(normalizedPath);
+                if (serverResult) {
+                    results[originalIndex] = serverResult;
+                    if (!serverResult.error && !opts.bypassCache) {
+                        const cacheKey = `${normalizedPath}:`;
+                        getCache[cacheKey] = {
+                            data: serverResult.data,
+                            expiresAt: now + GET_CACHE_TTL
+                        };
+                    }
+                }
+                else {
+                    results[originalIndex] = {
+                        path: normalizedPath,
+                        data: null,
+                        error: { code: 'NOT_FOUND', message: `No result returned for path ${normalizedPath}` }
+                    };
+                }
+            }
+            if (now - lastCacheCleanup > 5000) {
+                cleanupExpiredCache();
+                lastCacheCleanup = now;
+            }
+        }
+        catch (error) {
+            for (const originalIndex of uncachedIndices) {
+                results[originalIndex] = {
+                    path: normalizedPaths[originalIndex],
+                    data: null,
+                    error: { code: 'NOT_FOUND', message: error instanceof Error ? error.message : 'Unknown error' }
+                };
+            }
+        }
+    }
+    return results;
+}
 async function runQuery(absolutePath, queryName, queryArgs, opts) {
     const result = await runQueryMany([{ absolutePath, queryName, queryArgs }], opts);
     return result[0];
@@ -5007,6 +5091,7 @@ exports.getCachedData = getCachedData;
 exports.getConfig = getConfig;
 exports.getFiles = getFiles;
 exports.getIdToken = getIdToken;
+exports.getMany = getMany;
 exports.init = init;
 exports.reconnectWithNewAuth = reconnectWithNewAuth;
 exports.refreshSession = refreshSession;