s3db.js 4.0.2 → 4.1.1

package/dist/s3db.cjs.js

@@ -938,7 +938,7 @@ class Client extends EventEmitter {
       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) {
@@ -3482,9 +3482,10 @@ class Schema {
     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)) {
@@ -3565,6 +3566,7 @@ class Schema {
       version,
       attributes
     } = lodashEs.isString(data) ? JSON.parse(data) : data;
+    attributes = Schema._importAttributes(attributes);
     const schema = new Schema({
       map,
       name,
@@ -3574,22 +3576,60 @@ class Schema {
     });
     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])) {
@@ -3630,6 +3670,26 @@ class Schema {
     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 :
@@ -8945,7 +9005,7 @@ class Resource extends EventEmitter {
         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.`
           );
@@ -8953,6 +9013,25 @@ class Resource extends EventEmitter {
       }
     }
   }
+  /**
+   * 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
@@ -9015,17 +9094,38 @@ class Resource extends EventEmitter {
     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();
@@ -9507,7 +9607,19 @@ class Resource extends EventEmitter {
    */
   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")}`;
   }
   /**
@@ -9701,7 +9813,7 @@ class Database extends EventEmitter {
     this.version = "1";
     this.s3dbVersion = (() => {
       try {
-        return true ? "4.0.1" : "latest";
+        return true ? "4.1.0" : "latest";
       } catch (e) {
         return "latest";
       }