s3db.js 4.0.2 → 4.1.1

package/dist/s3db.es.js

@@ -1,6 +1,6 @@
 /* istanbul ignore file */
 import { customAlphabet, urlAlphabet } from 'nanoid';
-import { chunk, merge, cloneDeep, isEmpty, invert, uniq, isString as isString$1, get as get$1, set, isFunction as isFunction$1 } from 'lodash-es';
+import { chunk, merge, isEmpty, invert, uniq, cloneDeep, isString as isString$1, get as get$1, set, isFunction as isFunction$1 } from 'lodash-es';
 import { PromisePool } from '@supercharge/promise-pool';
 import { S3Client, PutObjectCommand, GetObjectCommand, HeadObjectCommand, CopyObjectCommand, DeleteObjectCommand, DeleteObjectsCommand, ListObjectsV2Command } from '@aws-sdk/client-s3';
 import { createHash } from 'crypto';
@@ -936,7 +936,7 @@ class Client extends EventEmitter {
       Key: this.config.keyPrefix ? path.join(this.config.keyPrefix, key) : key
     };
     try {
-      const response = await this.client.send(new HeadObjectCommand(options2));
+      const response = await this.sendCommand(new HeadObjectCommand(options2));
       this.emit("headObject", response, options2);
       return response;
     } catch (error) {
@@ -3480,9 +3480,10 @@ class Schema {
     this.attributes = attributes || {};
     this.passphrase = passphrase ?? "secret";
     this.options = merge({}, this.defaultOptions(), options);
+    const processedAttributes = this.preprocessAttributesForValidation(this.attributes);
     this.validator = new ValidatorManager({ autoEncrypt: false }).compile(merge(
       { $$async: true },
-      cloneDeep(this.attributes)
+      processedAttributes
     ));
     if (this.options.generateAutoHooks) this.generateAutoHooks();
     if (!isEmpty(map)) {
@@ -3563,6 +3564,7 @@ class Schema {
       version,
       attributes
     } = isString$1(data) ? JSON.parse(data) : data;
+    attributes = Schema._importAttributes(attributes);
     const schema = new Schema({
       map,
       name,
@@ -3572,22 +3574,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: 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])) {
@@ -3628,6 +3668,26 @@ class Schema {
     await this.applyHooksActions(rest, "afterUnmap");
     return 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 :
@@ -8943,7 +9003,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.`
           );
@@ -8951,6 +9011,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
@@ -9013,17 +9092,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();
@@ -9505,7 +9605,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:${createHash("sha256").update(stableString).digest("hex")}`;
   }
   /**
@@ -9699,7 +9811,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";
       }