s3db.js 4.1.7 → 4.1.10

package/dist/s3db.es.js

@@ -9234,36 +9234,97 @@ class Resource extends EventEmitter {
    */
   async get(id) {
     const key = this.getResourceKey(id);
-    const request = await this.client.headObject(key);
-    const objectVersion = this.extractVersionFromKey(key) || this.version;
-    const schema = await this.getSchemaForVersion(objectVersion);
-    let metadata = await schema.unmapper(request.Metadata);
-    const behaviorImpl = getBehavior(this.behavior);
-    let body = "";
-    if (request.ContentLength > 0) {
-      try {
-        const fullObject = await this.client.getObject(key);
-        body = await streamToString(fullObject.Body);
-      } catch (error) {
-        body = "";
+    try {
+      const request = await this.client.headObject(key);
+      const objectVersion = this.extractVersionFromKey(key) || this.version;
+      const schema = await this.getSchemaForVersion(objectVersion);
+      let metadata = await schema.unmapper(request.Metadata);
+      const behaviorImpl = getBehavior(this.behavior);
+      let body = "";
+      if (request.ContentLength > 0) {
+        try {
+          const fullObject = await this.client.getObject(key);
+          body = await streamToString(fullObject.Body);
+        } catch (error) {
+          console.warn(`Failed to read body for resource ${id}:`, error.message);
+          body = "";
+        }
       }
+      const { metadata: processedMetadata } = await behaviorImpl.handleGet({
+        resource: this,
+        metadata,
+        body
+      });
+      let data = processedMetadata;
+      data.id = id;
+      data._contentLength = request.ContentLength;
+      data._lastModified = request.LastModified;
+      data._hasContent = request.ContentLength > 0;
+      data._mimeType = request.ContentType || null;
+      if (request.VersionId) data._versionId = request.VersionId;
+      if (request.Expiration) data._expiresAt = request.Expiration;
+      data._definitionHash = this.getDefinitionHash();
+      this.emit("get", data);
+      return data;
+    } catch (error) {
+      if (error.message.includes("Cipher job failed") || error.message.includes("OperationError") || error.originalError?.message?.includes("Cipher job failed")) {
+        try {
+          console.warn(`Decryption failed for resource ${id}, attempting to get raw metadata`);
+          const request = await this.client.headObject(key);
+          const objectVersion = this.extractVersionFromKey(key) || this.version;
+          const tempSchema = new Schema({
+            name: this.name,
+            attributes: this.attributes,
+            passphrase: this.passphrase,
+            version: objectVersion,
+            options: {
+              ...this.options,
+              autoDecrypt: false,
+              // Disable decryption
+              autoEncrypt: false
+              // Disable encryption
+            }
+          });
+          let metadata = await tempSchema.unmapper(request.Metadata);
+          const behaviorImpl = getBehavior(this.behavior);
+          let body = "";
+          if (request.ContentLength > 0) {
+            try {
+              const fullObject = await this.client.getObject(key);
+              body = await streamToString(fullObject.Body);
+            } catch (bodyError) {
+              console.warn(`Failed to read body for resource ${id}:`, bodyError.message);
+              body = "";
+            }
+          }
+          const { metadata: processedMetadata } = await behaviorImpl.handleGet({
+            resource: this,
+            metadata,
+            body
+          });
+          let data = processedMetadata;
+          data.id = id;
+          data._contentLength = request.ContentLength;
+          data._lastModified = request.LastModified;
+          data._hasContent = request.ContentLength > 0;
+          data._mimeType = request.ContentType || null;
+          data._version = objectVersion;
+          data._decryptionFailed = true;
+          if (request.VersionId) data._versionId = request.VersionId;
+          if (request.Expiration) data._expiresAt = request.Expiration;
+          data._definitionHash = this.getDefinitionHash();
+          this.emit("get", data);
+          return data;
+        } catch (fallbackError) {
+          console.error(`Fallback attempt also failed for resource ${id}:`, fallbackError.message);
+        }
+      }
+      const enhancedError = new Error(`Failed to get resource with id '${id}': ${error.message}`);
+      enhancedError.originalError = error;
+      enhancedError.resourceId = id;
+      enhancedError.resourceKey = key;
+      throw enhancedError;
     }
-    const { metadata: processedMetadata } = await behaviorImpl.handleGet({
-      resource: this,
-      metadata,
-      body
-    });
-    let data = processedMetadata;
-    data.id = id;
-    data._contentLength = request.ContentLength;
-    data._lastModified = request.LastModified;
-    data._hasContent = request.ContentLength > 0;
-    data._mimeType = request.ContentType || null;
-    if (request.VersionId) data._versionId = request.VersionId;
-    if (request.Expiration) data._expiresAt = request.Expiration;
-    data._definitionHash = this.getDefinitionHash();
-    this.emit("get", data);
-    return data;
   }
   /**
    * Check if a resource exists by ID
@@ -9545,15 +9606,21 @@ class Resource extends EventEmitter {
     return { deletedCount, resource: this.name };
   }
   /**
-   * List resource IDs with optional partition filtering
+   * List resource IDs with optional partition filtering and pagination
    * @param {Object} [params] - List parameters
    * @param {string} [params.partition] - Partition name to list from
    * @param {Object} [params.partitionValues] - Partition field values to filter by
+   * @param {number} [params.limit] - Maximum number of results to return
+   * @param {number} [params.offset=0] - Offset for pagination
    * @returns {Promise<string[]>} Array of resource IDs (strings)
    * @example
    * // List all IDs
    * const allIds = await resource.listIds();
    * 
+   * // List IDs with pagination
+   * const firstPageIds = await resource.listIds({ limit: 10, offset: 0 });
+   * const secondPageIds = await resource.listIds({ limit: 10, offset: 10 });
+   * 
    * // List IDs from specific partition
    * const googleUserIds = await resource.listIds({
    *   partition: 'byUtmSource',
@@ -9566,7 +9633,7 @@ class Resource extends EventEmitter {
    *   partitionValues: { category: 'electronics', region: 'US' }
    * });
    */
-  async listIds({ partition = null, partitionValues = {} } = {}) {
+  async listIds({ partition = null, partitionValues = {}, limit, offset = 0 } = {}) {
     let prefix;
     if (partition && Object.keys(partitionValues).length > 0) {
       const partitionDef = this.options.partitions[partition];
@@ -9590,8 +9657,11 @@ class Resource extends EventEmitter {
     } else {
       prefix = `resource=${this.name}/v=${this.version}`;
     }
-    const keys = await this.client.getAllKeys({
-      prefix
+    const keys = await this.client.getKeysPage({
+      prefix,
+      offset,
+      amount: limit || 1e3
+      // Default to 1000 if no limit specified
     });
     const ids = keys.map((key) => {
       const parts = key.split("/");
@@ -9638,11 +9708,27 @@ class Resource extends EventEmitter {
       if (limit) {
         filteredIds2 = filteredIds2.slice(0, limit);
       }
-      const { results: results2 } = await PromisePool.for(filteredIds2).withConcurrency(this.parallelism).process(async (id) => {
-        return await this.get(id);
+      const { results: results2, errors: errors2 } = await PromisePool.for(filteredIds2).withConcurrency(this.parallelism).handleError(async (error, id) => {
+        console.warn(`Failed to get resource ${id}:`, error.message);
+        return null;
+      }).process(async (id) => {
+        try {
+          return await this.get(id);
+        } catch (error) {
+          if (error.message.includes("Cipher job failed") || error.message.includes("OperationError")) {
+            console.warn(`Decryption failed for ${id}, returning basic info`);
+            return {
+              id,
+              _decryptionFailed: true,
+              _error: error.message
+            };
+          }
+          throw error;
+        }
       });
-      this.emit("list", { partition, partitionValues, count: results2.length });
-      return results2;
+      const validResults2 = results2.filter((item) => item !== null);
+      this.emit("list", { partition, partitionValues, count: validResults2.length, errors: errors2.length });
+      return validResults2;
     }
     const partitionDef = this.options.partitions[partition];
     if (!partitionDef) {
@@ -9673,11 +9759,29 @@ class Resource extends EventEmitter {
     if (limit) {
       filteredIds = filteredIds.slice(0, limit);
     }
-    const { results } = await PromisePool.for(filteredIds).withConcurrency(this.parallelism).process(async (id) => {
-      return await this.getFromPartition({ id, partitionName: partition, partitionValues });
+    const { results, errors } = await PromisePool.for(filteredIds).withConcurrency(this.parallelism).handleError(async (error, id) => {
+      console.warn(`Failed to get partition resource ${id}:`, error.message);
+      return null;
+    }).process(async (id) => {
+      try {
+        return await this.getFromPartition({ id, partitionName: partition, partitionValues });
+      } catch (error) {
+        if (error.message.includes("Cipher job failed") || error.message.includes("OperationError")) {
+          console.warn(`Decryption failed for partition resource ${id}, returning basic info`);
+          return {
+            id,
+            _partition: partition,
+            _partitionValues: partitionValues,
+            _decryptionFailed: true,
+            _error: error.message
+          };
+        }
+        throw error;
+      }
     });
-    this.emit("list", { partition, partitionValues, count: results.length });
-    return results;
+    const validResults = results.filter((item) => item !== null);
+    this.emit("list", { partition, partitionValues, count: validResults.length, errors: errors.length });
+    return validResults;
   }
   /**
    * Get multiple resources by their IDs
@@ -9688,11 +9792,30 @@ class Resource extends EventEmitter {
    * users.forEach(user => console.log(user.name));
    */
   async getMany(ids) {
-    const { results } = await PromisePool.for(ids).withConcurrency(this.client.parallelism).process(async (id) => {
+    const { results, errors } = await PromisePool.for(ids).withConcurrency(this.client.parallelism).handleError(async (error, id) => {
+      console.warn(`Failed to get resource ${id}:`, error.message);
+      return {
+        id,
+        _error: error.message,
+        _decryptionFailed: error.message.includes("Cipher job failed") || error.message.includes("OperationError")
+      };
+    }).process(async (id) => {
       this.emit("id", id);
-      const data = await this.get(id);
-      this.emit("data", data);
-      return data;
+      try {
+        const data = await this.get(id);
+        this.emit("data", data);
+        return data;
+      } catch (error) {
+        if (error.message.includes("Cipher job failed") || error.message.includes("OperationError")) {
+          console.warn(`Decryption failed for ${id}, returning basic info`);
+          return {
+            id,
+            _decryptionFailed: true,
+            _error: error.message
+          };
+        }
+        throw error;
+      }
     });
     this.emit("getMany", ids.length);
     return results;
@@ -9707,9 +9830,28 @@ class Resource extends EventEmitter {
   async getAll() {
     let ids = await this.listIds();
     if (ids.length === 0) return [];
-    const { results } = await PromisePool.for(ids).withConcurrency(this.client.parallelism).process(async (id) => {
-      const data = await this.get(id);
-      return data;
+    const { results, errors } = await PromisePool.for(ids).withConcurrency(this.client.parallelism).handleError(async (error, id) => {
+      console.warn(`Failed to get resource ${id}:`, error.message);
+      return {
+        id,
+        _error: error.message,
+        _decryptionFailed: error.message.includes("Cipher job failed") || error.message.includes("OperationError")
+      };
+    }).process(async (id) => {
+      try {
+        const data = await this.get(id);
+        return data;
+      } catch (error) {
+        if (error.message.includes("Cipher job failed") || error.message.includes("OperationError")) {
+          console.warn(`Decryption failed for ${id}, returning basic info`);
+          return {
+            id,
+            _decryptionFailed: true,
+            _error: error.message
+          };
+        }
+        throw error;
+      }
     });
     this.emit("getAll", results.length);
     return results;
@@ -9721,6 +9863,7 @@ class Resource extends EventEmitter {
    * @param {number} [params.size=100] - Page size
    * @param {string} [params.partition] - Partition name to page from
    * @param {Object} [params.partitionValues] - Partition field values to filter by
+   * @param {boolean} [params.skipCount=false] - Skip total count for performance (useful for large collections)
    * @returns {Promise<Object>} Page result with items and pagination info
    * @example
    * // Get first page of all resources
@@ -9735,22 +9878,43 @@ class Resource extends EventEmitter {
    *   offset: 0,
    *   size: 5
    * });
+   * 
+   * // Skip count for performance in large collections
+   * const fastPage = await resource.page({ 
+   *   offset: 0, 
+   *   size: 100, 
+   *   skipCount: true 
+   * });
+   * console.log(`Got ${fastPage.items.length} items`); // totalItems will be null
    */
-  async page({ offset = 0, size = 100, partition = null, partitionValues = {} } = {}) {
-    const ids = await this.listIds({ partition, partitionValues });
-    const totalItems = ids.length;
-    const totalPages = Math.ceil(totalItems / size);
+  async page({ offset = 0, size = 100, partition = null, partitionValues = {}, skipCount = false } = {}) {
+    let totalItems = null;
+    let totalPages = null;
+    if (!skipCount) {
+      totalItems = await this.count({ partition, partitionValues });
+      totalPages = Math.ceil(totalItems / size);
+    }
     const page = Math.floor(offset / size);
-    const pageIds = ids.slice(offset, offset + size);
-    const items = await Promise.all(
-      pageIds.map((id) => this.get(id))
-    );
+    const items = await this.list({
+      partition,
+      partitionValues,
+      limit: size,
+      offset
+    });
     const result = {
       items,
       totalItems,
       page,
       pageSize: size,
-      totalPages
+      totalPages,
+      // Add additional metadata for debugging
+      _debug: {
+        requestedSize: size,
+        requestedOffset: offset,
+        actualItemsReturned: items.length,
+        skipCount,
+        hasTotalItems: totalItems !== null
+      }
     };
     this.emit("page", result);
     return result;
@@ -9902,7 +10066,27 @@ class Resource extends EventEmitter {
    * @returns {Object} Schema object for the version
    */
   async getSchemaForVersion(version) {
-    return this.schema;
+    if (version === this.version) {
+      return this.schema;
+    }
+    try {
+      const compatibleSchema = new Schema({
+        name: this.name,
+        attributes: this.attributes,
+        passphrase: this.passphrase,
+        version,
+        options: {
+          ...this.options,
+          // For older versions, be more lenient with decryption
+          autoDecrypt: true,
+          autoEncrypt: true
+        }
+      });
+      return compatibleSchema;
+    } catch (error) {
+      console.warn(`Failed to create compatible schema for version ${version}, using current schema:`, error.message);
+      return this.schema;
+    }
   }
   /**
    * Create partition references after insert
@@ -10146,7 +10330,7 @@ class Database extends EventEmitter {
     this.version = "1";
     this.s3dbVersion = (() => {
       try {
-        return true ? "4.1.6" : "latest";
+        return true ? "4.1.9" : "latest";
       } catch (e) {
         return "latest";
       }