s3db.js 4.0.2 → 4.1.1

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) {
@@ -3474,9 +3474,10 @@ ${JSON.stringify(validation, null, 2)}`
       this.attributes = attributes || {};
       this.passphrase = passphrase ?? "secret";
       this.options = lodashEs.merge({}, this.defaultOptions(), options);
+      const processedAttributes = this.preprocessAttributesForValidation(this.attributes);
       this.validator = new ValidatorManager({ autoEncrypt: false }).compile(lodashEs.merge(
         { $$async: true },
-        lodashEs.cloneDeep(this.attributes)
+        processedAttributes
       ));
       if (this.options.generateAutoHooks) this.generateAutoHooks();
       if (!lodashEs.isEmpty(map)) {
@@ -3557,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,
@@ -3566,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])) {
@@ -3622,6 +3662,26 @@ ${JSON.stringify(validation, null, 2)}`
       await this.applyHooksActions(rest, "afterUnmap");
       return flat.unflatten(rest);
     }
+    /**
+     * Preprocess attributes to convert nested objects into validator-compatible format
+     * @param {Object} attributes - Original attributes
+     * @returns {Object} Processed attributes for validator
+     */
+    preprocessAttributesForValidation(attributes) {
+      const processed = {};
+      for (const [key, value] of Object.entries(attributes)) {
+        if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+          processed[key] = {
+            type: "object",
+            properties: this.preprocessAttributesForValidation(value),
+            strict: false
+          };
+        } else {
+          processed[key] = value;
+        }
+      }
+      return processed;
+    }
   }
 
   var global$1 = (typeof global !== "undefined" ? global :
@@ -8937,7 +8997,7 @@ ${JSON.stringify(validation, null, 2)}`
           continue;
         }
         for (const fieldName of Object.keys(partitionDef.fields)) {
-          if (!currentAttributes.includes(fieldName)) {
+          if (!this.fieldExistsInAttributes(fieldName)) {
             throw new Error(
               `Partition '${partitionName}' uses field '${fieldName}' which does not exist in resource version '${this.version}'. Available fields: ${currentAttributes.join(", ")}. This version of resource does not have support for this partition.`
             );
@@ -8945,6 +9005,25 @@ ${JSON.stringify(validation, null, 2)}`
         }
       }
     }
+    /**
+     * Check if a field (including nested fields) exists in the current attributes
+     * @param {string} fieldName - Field name (can be nested like 'utm.source')
+     * @returns {boolean} True if field exists
+     */
+    fieldExistsInAttributes(fieldName) {
+      if (!fieldName.includes(".")) {
+        return Object.keys(this.attributes || {}).includes(fieldName);
+      }
+      const keys = fieldName.split(".");
+      let currentLevel = this.attributes || {};
+      for (const key of keys) {
+        if (!currentLevel || typeof currentLevel !== "object" || !(key in currentLevel)) {
+          return false;
+        }
+        currentLevel = currentLevel[key];
+      }
+      return true;
+    }
     /**
      * Apply a single partition rule to a field value
      * @param {*} value - The field value
@@ -9007,17 +9086,38 @@ ${JSON.stringify(validation, null, 2)}`
       const partitionSegments = [];
       const sortedFields = Object.entries(partition.fields).sort(([a], [b]) => a.localeCompare(b));
       for (const [fieldName, rule] of sortedFields) {
-        const fieldValue = this.applyPartitionRule(data[fieldName], rule);
-        if (fieldValue === void 0 || fieldValue === null) {
+        const fieldValue = this.getNestedFieldValue(data, fieldName);
+        const transformedValue = this.applyPartitionRule(fieldValue, rule);
+        if (transformedValue === void 0 || transformedValue === null) {
           return null;
         }
-        partitionSegments.push(`${fieldName}=${fieldValue}`);
+        partitionSegments.push(`${fieldName}=${transformedValue}`);
       }
       if (partitionSegments.length === 0) {
         return null;
       }
       return join(`resource=${this.name}`, `partition=${partitionName}`, ...partitionSegments, `id=${id}`);
     }
+    /**
+     * Get nested field value from data object using dot notation
+     * @param {Object} data - Data object
+     * @param {string} fieldPath - Field path (e.g., "utm.source", "address.city")
+     * @returns {*} Field value
+     */
+    getNestedFieldValue(data, fieldPath) {
+      if (!fieldPath.includes(".")) {
+        return data[fieldPath];
+      }
+      const keys = fieldPath.split(".");
+      let value = data;
+      for (const key of keys) {
+        if (value === null || value === void 0 || typeof value !== "object") {
+          return void 0;
+        }
+        value = value[key];
+      }
+      return value;
+    }
     async insert({ id, ...attributes }) {
       if (this.options.timestamps) {
         attributes.createdAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -9499,7 +9599,19 @@ ${JSON.stringify(validation, null, 2)}`
      */
     getDefinitionHash() {
       const exportedSchema = this.schema.export();
-      const stableString = jsonStableStringify(exportedSchema);
+      const stableSchema = {
+        ...exportedSchema,
+        attributes: { ...exportedSchema.attributes }
+      };
+      if (this.options.timestamps) {
+        delete stableSchema.attributes.createdAt;
+        delete stableSchema.attributes.updatedAt;
+        if (stableSchema.options && stableSchema.options.partitions) {
+          delete stableSchema.options.partitions.byCreatedDate;
+          delete stableSchema.options.partitions.byUpdatedDate;
+        }
+      }
+      const stableString = jsonStableStringify(stableSchema);
       return `sha256:${crypto.createHash("sha256").update(stableString).digest("hex")}`;
     }
     /**
@@ -9693,7 +9805,7 @@ ${JSON.stringify(validation, null, 2)}`
       this.version = "1";
       this.s3dbVersion = (() => {
         try {
-          return true ? "4.0.1" : "latest";
+          return true ? "4.1.0" : "latest";
         } catch (e) {
           return "latest";
         }