s3db.js 4.1.0 → 4.1.2

package/dist/s3db.iife.js

@@ -930,7 +930,7 @@ ${JSON.stringify(validation, null, 2)}`
         Key: this.config.keyPrefix ? path.join(this.config.keyPrefix, key) : key
       };
       try {
-        const response = await this.client.send(new clientS3.HeadObjectCommand(options2));
+        const response = await this.sendCommand(new clientS3.HeadObjectCommand(options2));
         this.emit("headObject", response, options2);
         return response;
       } catch (error) {
@@ -3558,6 +3558,7 @@ ${JSON.stringify(validation, null, 2)}`
         version,
         attributes
       } = lodashEs.isString(data) ? JSON.parse(data) : data;
+      attributes = Schema._importAttributes(attributes);
       const schema = new Schema({
         map,
         name,
@@ -3567,22 +3568,60 @@ ${JSON.stringify(validation, null, 2)}`
       });
       return schema;
     }
+    /**
+     * Recursively import attributes, parsing only stringified objects (legacy)
+     */
+    static _importAttributes(attrs) {
+      if (typeof attrs === "string") {
+        try {
+          const parsed = JSON.parse(attrs);
+          if (typeof parsed === "object" && parsed !== null) {
+            return Schema._importAttributes(parsed);
+          }
+        } catch (e) {
+        }
+        return attrs;
+      }
+      if (Array.isArray(attrs)) {
+        return attrs.map((a) => Schema._importAttributes(a));
+      }
+      if (typeof attrs === "object" && attrs !== null) {
+        const out = {};
+        for (const [k, v] of Object.entries(attrs)) {
+          out[k] = Schema._importAttributes(v);
+        }
+        return out;
+      }
+      return attrs;
+    }
     export() {
       const data = {
         version: this.version,
         name: this.name,
         options: this.options,
-        attributes: lodashEs.cloneDeep(this.attributes),
+        attributes: this._exportAttributes(this.attributes),
         map: this.map
       };
-      for (const [name, definition] of Object.entries(this.attributes)) {
-        if (typeof definition !== "string") {
-          data.attributes[name] = JSON.stringify(definition);
-        } else {
-          data.attributes[name] = definition;
+      return data;
+    }
+    /**
+     * Recursively export attributes, keeping objects as objects and only serializing leaves as string
+     */
+    _exportAttributes(attrs) {
+      if (typeof attrs === "string") {
+        return attrs;
+      }
+      if (Array.isArray(attrs)) {
+        return attrs.map((a) => this._exportAttributes(a));
+      }
+      if (typeof attrs === "object" && attrs !== null) {
+        const out = {};
+        for (const [k, v] of Object.entries(attrs)) {
+          out[k] = this._exportAttributes(v);
         }
+        return out;
       }
-      return data;
+      return attrs;
     }
     async applyHooksActions(resourceItem, hook) {
       for (const [attribute, actions] of Object.entries(this.options.hooks[hook])) {
@@ -9559,8 +9598,13 @@ ${JSON.stringify(validation, null, 2)}`
      * @returns {string} SHA256 hash of the schema definition
      */
     getDefinitionHash() {
-      const exportedSchema = this.schema.export();
-      const stableString = jsonStableStringify(exportedSchema);
+      const attributes = this.schema.export().attributes;
+      const stableAttributes = { ...attributes };
+      if (this.options.timestamps) {
+        delete stableAttributes.createdAt;
+        delete stableAttributes.updatedAt;
+      }
+      const stableString = jsonStableStringify(stableAttributes);
       return `sha256:${crypto.createHash("sha256").update(stableString).digest("hex")}`;
     }
     /**
@@ -9754,7 +9798,7 @@ ${JSON.stringify(validation, null, 2)}`
       this.version = "1";
       this.s3dbVersion = (() => {
         try {
-          return true ? "4.0.2" : "latest";
+          return true ? "4.1.1" : "latest";
         } catch (e) {
           return "latest";
         }
@@ -9869,7 +9913,13 @@ ${JSON.stringify(validation, null, 2)}`
      * @returns {string} SHA256 hash
      */
     generateDefinitionHash(definition) {
-      const stableString = jsonStableStringify(definition);
+      const attributes = definition.attributes;
+      const stableAttributes = { ...attributes };
+      if (definition.options?.timestamps) {
+        delete stableAttributes.createdAt;
+        delete stableAttributes.updatedAt;
+      }
+      const stableString = jsonStableStringify(stableAttributes);
       return `sha256:${crypto.createHash("sha256").update(stableString).digest("hex")}`;
     }
     /**