s3db.js 7.4.0 → 7.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "s3db.js",
-  "version": "7.4.0",
+  "version": "7.4.2",
   "description": "Use AWS S3, the world's most reliable document storage, as a database with this ORM.",
   "main": "dist/s3db.cjs.js",
   "module": "dist/s3db.es.js",

package/src/client.class.js

@@ -103,7 +103,17 @@ export class Client extends EventEmitter {
       for (const [k, v] of Object.entries(metadata)) {
         // Ensure key is a valid string and value is a string
         const validKey = String(k).replace(/[^a-zA-Z0-9\-_]/g, '_');
-        stringMetadata[validKey] = String(v);
+        const stringValue = String(v);
+        
+        // Check if value contains non-ASCII characters that might be corrupted by HTTP headers
+        const hasSpecialChars = /[^\x00-\x7F]/.test(stringValue);
+        
+        if (hasSpecialChars) {
+          // Encode as base64 without prefix - we'll detect it intelligently on read
+          stringMetadata[validKey] = Buffer.from(stringValue, 'utf8').toString('base64');
+        } else {
+          stringMetadata[validKey] = stringValue;
+        }
       }
     }
     
@@ -141,9 +151,39 @@ export class Client extends EventEmitter {
       Bucket: this.config.bucket,
       Key: keyPrefix ? path.join(keyPrefix, key) : key,
     };
+ 
     let response, error;
     try {
       response = await this.sendCommand(new GetObjectCommand(options));
+      
+      // Smart decode: try to detect base64-encoded UTF-8 values without prefix
+      if (response.Metadata) {
+        const decodedMetadata = {};
+        for (const [key, value] of Object.entries(response.Metadata)) {
+          if (typeof value === 'string') {
+            // Try to decode as base64 and check if it's valid UTF-8 with special chars
+            try {
+              const decoded = Buffer.from(value, 'base64').toString('utf8');
+              // Check if decoded string is different from original and contains non-ASCII chars
+              const hasSpecialChars = /[^\x00-\x7F]/.test(decoded);
+              const isValidBase64 = Buffer.from(decoded, 'utf8').toString('base64') === value;
+              
+              if (isValidBase64 && hasSpecialChars && decoded !== value) {
+                decodedMetadata[key] = decoded;
+              } else {
+                decodedMetadata[key] = value;
+              }
+            } catch (decodeError) {
+              // If decode fails, use original value
+              decodedMetadata[key] = value;
+            }
+          } else {
+            decodedMetadata[key] = value;
+          }
+        }
+        response.Metadata = decodedMetadata;
+      }
+      
       return response;
     } catch (err) {
       error = err;

package/src/database.class.js

@@ -113,6 +113,23 @@ export class Database extends EventEmitter {
       
       if (versionData) {
         // Extract configuration from version data at root level
+        // Restore ID generator configuration
+        let restoredIdGenerator, restoredIdSize;
+        if (versionData.idGenerator !== undefined) {
+          if (versionData.idGenerator === 'custom_function') {
+            // Custom function was used but can't be restored - use default
+            restoredIdGenerator = undefined;
+            restoredIdSize = versionData.idSize || 22;
+          } else if (typeof versionData.idGenerator === 'number') {
+            // Size-based generator
+            restoredIdGenerator = versionData.idGenerator;
+            restoredIdSize = versionData.idSize || versionData.idGenerator;
+          }
+        } else {
+          // Legacy resource without saved ID config
+          restoredIdSize = versionData.idSize || 22;
+        }
+
         this.resources[name] = new Resource({
           name,
           client: this.client,
@@ -131,7 +148,9 @@ export class Database extends EventEmitter {
           autoDecrypt: versionData.autoDecrypt !== undefined ? versionData.autoDecrypt : true,
           hooks: versionData.hooks || {},
           versioningEnabled: this.versioningEnabled,
-          map: versionData.map
+          map: versionData.map,
+          idGenerator: restoredIdGenerator,
+          idSize: restoredIdSize
         });
       }
     }
@@ -334,6 +353,8 @@ export class Database extends EventEmitter {
             autoDecrypt: resource.config.autoDecrypt,
             cache: resource.config.cache,
             hooks: resource.config.hooks,
+            idSize: resource.idSize,
+            idGenerator: resource.idGeneratorType,
             createdAt: isNewVersion ? new Date().toISOString() : existingVersionData?.createdAt
           }
         }

package/src/resource.class.js

@@ -142,6 +142,19 @@ export class Resource extends EventEmitter {
 
     // Configure ID generator
     this.idGenerator = this.configureIdGenerator(customIdGenerator, idSize);
+    
+    // Store ID configuration for persistence
+    // If customIdGenerator is a number, use it as idSize
+    // Otherwise, use the provided idSize or default to 22
+    if (typeof customIdGenerator === 'number' && customIdGenerator > 0) {
+      this.idSize = customIdGenerator;
+    } else if (typeof idSize === 'number' && idSize > 0) {
+      this.idSize = idSize;
+    } else {
+      this.idSize = 22;
+    }
+    
+    this.idGeneratorType = this.getIdGeneratorType(customIdGenerator, this.idSize);
 
     // Store configuration - all at root level
     this.config = {
@@ -220,9 +233,9 @@ export class Resource extends EventEmitter {
    * @private
    */
   configureIdGenerator(customIdGenerator, idSize) {
-    // If a custom function is provided, use it
+    // If a custom function is provided, wrap it to ensure string output
     if (typeof customIdGenerator === 'function') {
-      return customIdGenerator;
+      return () => String(customIdGenerator());
     }
     // If customIdGenerator is a number (size), create a generator with that size
     if (typeof customIdGenerator === 'number' && customIdGenerator > 0) {
@@ -236,6 +249,22 @@ export class Resource extends EventEmitter {
     return defaultIdGenerator;
   }
 
+  /**
+   * Get a serializable representation of the ID generator type
+   * @param {Function|number} customIdGenerator - Custom ID generator function or size
+   * @param {number} idSize - Size for auto-generated IDs
+   * @returns {string|number} Serializable ID generator type
+   * @private
+   */
+  getIdGeneratorType(customIdGenerator, idSize) {
+    // If a custom function is provided
+    if (typeof customIdGenerator === 'function') {
+      return 'custom_function';
+    }
+    // For number generators or default size, return the actual idSize
+    return idSize;
+  }
+
   /**
    * Get resource options (for backward compatibility with tests)
    */