s3db.js 4.1.14 → 5.1.0

package/dist/s3db.cjs.js

@@ -247,7 +247,7 @@ var substr = 'ab'.substr(-1) === 'b' ?
 
 const idGenerator = nanoid.customAlphabet(nanoid.urlAlphabet, 22);
 const passwordAlphabet = "ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz23456789";
-nanoid.customAlphabet(passwordAlphabet, 12);
+const passwordGenerator = nanoid.customAlphabet(passwordAlphabet, 12);
 
 var domain;
 
@@ -3392,7 +3392,7 @@ function requireJsonStableStringify () {
 var jsonStableStringifyExports = requireJsonStableStringify();
 var jsonStableStringify = /*@__PURE__*/getDefaultExportFromCjs(jsonStableStringifyExports);
 
-async function custom(actual, errors, schema) {
+async function secretHandler(actual, errors, schema) {
   if (!this.passphrase) {
     errors.push({ actual, type: "encryptionKeyMissing" });
     return actual;
@@ -3405,6 +3405,10 @@ async function custom(actual, errors, schema) {
   }
   return actual;
 }
+async function jsonHandler(actual, errors, schema) {
+  if (lodashEs.isString(actual)) return actual;
+  return JSON.stringify(actual);
+}
 class Validator extends FastestValidator {
   constructor({ options, passphrase, autoEncrypt = true } = {}) {
     super(lodashEs.merge({}, {
@@ -3426,7 +3430,7 @@ class Validator extends FastestValidator {
     this.autoEncrypt = autoEncrypt;
     this.alias("secret", {
       type: "string",
-      custom: this.autoEncrypt ? custom : void 0,
+      custom: this.autoEncrypt ? secretHandler : void 0,
       messages: {
         string: "The '{field}' field must be a string.",
         stringMin: "This secret '{field}' field length must be at least {expected} long."
@@ -3434,11 +3438,15 @@ class Validator extends FastestValidator {
     });
     this.alias("secretAny", {
       type: "any",
-      custom: this.autoEncrypt ? custom : void 0
+      custom: this.autoEncrypt ? secretHandler : void 0
     });
     this.alias("secretNumber", {
       type: "number",
-      custom: this.autoEncrypt ? custom : void 0
+      custom: this.autoEncrypt ? secretHandler : void 0
+    });
+    this.alias("json", {
+      type: "any",
+      custom: this.autoEncrypt ? jsonHandler : void 0
     });
   }
 }
@@ -3450,10 +3458,31 @@ const ValidatorManager = new Proxy(Validator, {
   }
 });
 
+function toBase36(num) {
+  return num.toString(36);
+}
+function generateBase36Mapping(keys) {
+  const mapping = {};
+  const reversedMapping = {};
+  keys.forEach((key, index) => {
+    const base36Key = toBase36(index);
+    mapping[key] = base36Key;
+    reversedMapping[base36Key] = key;
+  });
+  return { mapping, reversedMapping };
+}
 const SchemaActions = {
   trim: (value) => value.trim(),
   encrypt: (value, { passphrase }) => encrypt(value, passphrase),
-  decrypt: (value, { passphrase }) => decrypt(value, passphrase),
+  decrypt: async (value, { passphrase }) => {
+    try {
+      const raw = await decrypt(value, passphrase);
+      return raw;
+    } catch (error) {
+      console.warn(`Schema decrypt error: ${error}`, error);
+      return value;
+    }
+  },
   toString: (value) => String(value),
   fromArray: (value, { separator }) => {
     if (value === null || value === void 0 || !Array.isArray(value)) {
@@ -3544,8 +3573,9 @@ class Schema {
       const leafKeys = Object.keys(flatAttrs).filter((k) => !k.includes("$$"));
       const objectKeys = this.extractObjectKeys(this.attributes);
       const allKeys = [.../* @__PURE__ */ new Set([...leafKeys, ...objectKeys])];
-      this.reversedMap = { ...allKeys };
-      this.map = lodashEs.invert(this.reversedMap);
+      const { mapping, reversedMapping } = generateBase36Mapping(allKeys);
+      this.map = mapping;
+      this.reversedMap = reversedMapping;
     }
   }
   defaultOptions() {
@@ -3586,24 +3616,27 @@ class Schema {
       if (definition.includes("array")) {
         this.addHook("beforeMap", name, "fromArray");
         this.addHook("afterUnmap", name, "toArray");
-      } else {
-        if (definition.includes("secret")) {
-          if (this.options.autoEncrypt) {
-            this.addHook("beforeMap", name, "encrypt");
-          }
-          if (this.options.autoDecrypt) {
-            this.addHook("afterUnmap", name, "decrypt");
-          }
-        }
-        if (definition.includes("number")) {
-          this.addHook("beforeMap", name, "toString");
-          this.addHook("afterUnmap", name, "toNumber");
+      }
+      if (definition.includes("secret")) {
+        if (this.options.autoEncrypt) {
+          this.addHook("beforeMap", name, "encrypt");
         }
-        if (definition.includes("boolean")) {
-          this.addHook("beforeMap", name, "fromBool");
-          this.addHook("afterUnmap", name, "toBool");
+        if (this.options.autoDecrypt) {
+          this.addHook("afterUnmap", name, "decrypt");
         }
       }
+      if (definition.includes("number")) {
+        this.addHook("beforeMap", name, "toString");
+        this.addHook("afterUnmap", name, "toNumber");
+      }
+      if (definition.includes("boolean")) {
+        this.addHook("beforeMap", name, "fromBool");
+        this.addHook("afterUnmap", name, "toBool");
+      }
+      if (definition.includes("json")) {
+        this.addHook("beforeMap", name, "toJSON");
+        this.addHook("afterUnmap", name, "fromJSON");
+      }
     }
   }
   static import(data) {
@@ -8618,7 +8651,6 @@ function calculateUTF8Bytes(str) {
 function calculateAttributeNamesSize(mappedObject) {
   let totalSize = 0;
   for (const key of Object.keys(mappedObject)) {
-    if (key === "_v") continue;
     totalSize += calculateUTF8Bytes(key);
   }
   return totalSize;
@@ -8662,6 +8694,30 @@ function calculateTotalSize(mappedObject) {
   const namesSize = calculateAttributeNamesSize(mappedObject);
   return valueTotal + namesSize;
 }
+function getSizeBreakdown(mappedObject) {
+  const valueSizes = calculateAttributeSizes(mappedObject);
+  const namesSize = calculateAttributeNamesSize(mappedObject);
+  const valueTotal = Object.values(valueSizes).reduce((sum, size) => sum + size, 0);
+  const total = valueTotal + namesSize;
+  const sortedAttributes = Object.entries(valueSizes).sort(([, a], [, b]) => b - a).map(([key, size]) => ({
+    attribute: key,
+    size,
+    percentage: (size / total * 100).toFixed(2) + "%"
+  }));
+  return {
+    total,
+    valueSizes,
+    namesSize,
+    valueTotal,
+    breakdown: sortedAttributes,
+    // Add detailed breakdown including names
+    detailedBreakdown: {
+      values: valueTotal,
+      names: namesSize,
+      total
+    }
+  };
+}
 
 const S3_METADATA_LIMIT_BYTES = 2048;
 async function handleInsert$3({ resource, data, mappedData }) {
@@ -8882,6 +8938,7 @@ function getBehavior(behaviorName) {
   }
   return behavior;
 }
+const AVAILABLE_BEHAVIORS = Object.keys(behaviors);
 const DEFAULT_BEHAVIOR = "user-management";
 
 class Resource extends EventEmitter {
@@ -8951,17 +9008,8 @@ ${validation.errors.join("\n")}`);
       partitions = {},
       paranoid = true,
       allNestedObjectsOptional = true,
-      hooks = {},
-      options = {}
+      hooks = {}
     } = config;
-    const mergedOptions = {
-      cache: typeof options.cache === "boolean" ? options.cache : cache,
-      autoDecrypt: typeof options.autoDecrypt === "boolean" ? options.autoDecrypt : autoDecrypt,
-      timestamps: typeof options.timestamps === "boolean" ? options.timestamps : timestamps,
-      paranoid: typeof options.paranoid === "boolean" ? options.paranoid : paranoid,
-      allNestedObjectsOptional: typeof options.allNestedObjectsOptional === "boolean" ? options.allNestedObjectsOptional : allNestedObjectsOptional,
-      partitions: options.partitions || partitions || {}
-    };
     this.name = name;
     this.client = client;
     this.version = version;
@@ -8970,13 +9018,13 @@ ${validation.errors.join("\n")}`);
     this.parallelism = parallelism;
     this.passphrase = passphrase ?? "secret";
     this.config = {
-      cache: mergedOptions.cache,
+      cache,
       hooks,
-      paranoid: mergedOptions.paranoid,
-      timestamps: mergedOptions.timestamps,
-      partitions: mergedOptions.partitions,
-      autoDecrypt: mergedOptions.autoDecrypt,
-      allNestedObjectsOptional: mergedOptions.allNestedObjectsOptional
+      paranoid,
+      timestamps,
+      partitions,
+      autoDecrypt,
+      allNestedObjectsOptional
     };
     this.hooks = {
       preInsert: [],
@@ -8987,39 +9035,7 @@ ${validation.errors.join("\n")}`);
       afterDelete: []
     };
     this.attributes = attributes || {};
-    if (this.config.timestamps) {
-      this.attributes.createdAt = "string|optional";
-      this.attributes.updatedAt = "string|optional";
-      if (!this.config.partitions) {
-        this.config.partitions = {};
-      }
-      if (!this.config.partitions.byCreatedDate) {
-        this.config.partitions.byCreatedDate = {
-          fields: {
-            createdAt: "date|maxlength:10"
-          }
-        };
-      }
-      if (!this.config.partitions.byUpdatedDate) {
-        this.config.partitions.byUpdatedDate = {
-          fields: {
-            updatedAt: "date|maxlength:10"
-          }
-        };
-      }
-    }
-    this.schema = new Schema({
-      name,
-      attributes: this.attributes,
-      passphrase,
-      version: this.version,
-      options: {
-        autoDecrypt: this.config.autoDecrypt,
-        allNestedObjectsOptional: this.config.allNestedObjectsOptional
-      }
-    });
-    this.setupPartitionHooks();
-    this.validatePartitions();
+    this.applyConfiguration();
     if (hooks) {
       for (const [event, hooksArr] of Object.entries(hooks)) {
         if (Array.isArray(hooksArr) && this.hooks[event]) {
@@ -9058,15 +9074,17 @@ ${validation.errors.join("\n")}`);
     return exported;
   }
   /**
-   * Update resource attributes and rebuild schema
-   * @param {Object} newAttributes - New attributes definition
+   * Apply configuration settings (timestamps, partitions, hooks)
+   * This method ensures that all configuration-dependent features are properly set up
    */
-  updateAttributes(newAttributes) {
-    const oldAttributes = this.attributes;
-    this.attributes = newAttributes;
+  applyConfiguration() {
     if (this.config.timestamps) {
-      newAttributes.createdAt = "string|optional";
-      newAttributes.updatedAt = "string|optional";
+      if (!this.attributes.createdAt) {
+        this.attributes.createdAt = "string|optional";
+      }
+      if (!this.attributes.updatedAt) {
+        this.attributes.updatedAt = "string|optional";
+      }
       if (!this.config.partitions) {
         this.config.partitions = {};
       }
@@ -9085,9 +9103,10 @@ ${validation.errors.join("\n")}`);
         };
       }
     }
+    this.setupPartitionHooks();
     this.schema = new Schema({
       name: this.name,
-      attributes: newAttributes,
+      attributes: this.attributes,
       passphrase: this.passphrase,
       version: this.version,
       options: {
@@ -9095,8 +9114,16 @@ ${validation.errors.join("\n")}`);
         allNestedObjectsOptional: this.config.allNestedObjectsOptional
       }
     });
-    this.setupPartitionHooks();
     this.validatePartitions();
+  }
+  /**
+   * Update resource attributes and rebuild schema
+   * @param {Object} newAttributes - New attributes definition
+   */
+  updateAttributes(newAttributes) {
+    const oldAttributes = this.attributes;
+    this.attributes = newAttributes;
+    this.applyConfiguration();
     return { oldAttributes, newAttributes };
   }
   /**
@@ -9184,7 +9211,7 @@ ${validation.errors.join("\n")}`);
       for (const fieldName of Object.keys(partitionDef.fields)) {
         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.`
+            `Partition '${partitionName}' uses field '${fieldName}' which does not exist in resource attributes. Available fields: ${currentAttributes.join(", ")}.`
           );
         }
       }
@@ -9297,7 +9324,11 @@ ${validation.errors.join("\n")}`);
     if (partitionSegments.length === 0) {
       return null;
     }
-    return join(`resource=${this.name}`, `partition=${partitionName}`, ...partitionSegments, `id=${id}`);
+    const finalId = id || data?.id;
+    if (!finalId) {
+      return null;
+    }
+    return join(`resource=${this.name}`, `partition=${partitionName}`, ...partitionSegments, `id=${finalId}`);
   }
   /**
    * Get nested field value from data object using dot notation
@@ -9526,12 +9557,12 @@ ${validation.errors.join("\n")}`);
    * console.log(updatedUser.updatedAt); // ISO timestamp
    */
   async update(id, attributes) {
-    const live = await this.get(id);
+    const originalData = await this.get(id);
     if (this.config.timestamps) {
       attributes.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     }
     const preProcessedData = await this.executeHooks("preUpdate", attributes);
-    const attrs = lodashEs.merge(live, preProcessedData);
+    const attrs = lodashEs.merge(originalData, preProcessedData);
     delete attrs.id;
     const { isValid, errors, data: validated } = await this.validate(attrs);
     if (!isValid) {
@@ -9542,6 +9573,9 @@ ${validation.errors.join("\n")}`);
         validation: errors
       });
     }
+    const oldData = { ...originalData, id };
+    const newData = { ...validated, id };
+    await this.handlePartitionReferenceUpdates(oldData, newData);
     const mappedData = await this.schema.mapper(validated);
     const behaviorImpl = getBehavior(this.behavior);
     const { mappedData: processedMetadata, body } = await behaviorImpl.handleUpdate({
@@ -9577,7 +9611,6 @@ ${validation.errors.join("\n")}`);
     });
     validated.id = id;
     await this.executeHooks("afterUpdate", validated);
-    await this.updatePartitionReferences(validated);
     this.emit("update", preProcessedData, validated);
     return validated;
   }
@@ -9864,23 +9897,104 @@ ${validation.errors.join("\n")}`);
    * });
    */
   async list({ partition = null, partitionValues = {}, limit, offset = 0 } = {}) {
-    if (!partition) {
-      const ids2 = await this.listIds({ partition, partitionValues });
-      let filteredIds2 = ids2.slice(offset);
+    try {
+      if (!partition) {
+        let ids2 = [];
+        try {
+          ids2 = await this.listIds({ partition, partitionValues });
+        } catch (listIdsError) {
+          console.warn(`Failed to get list IDs:`, listIdsError.message);
+          return [];
+        }
+        let filteredIds2 = ids2.slice(offset);
+        if (limit) {
+          filteredIds2 = filteredIds2.slice(0, limit);
+        }
+        const { results: results2, errors: errors2 } = await promisePool.PromisePool.for(filteredIds2).withConcurrency(this.parallelism).handleError(async (error, id) => {
+          console.warn(`Failed to get resource ${id}:`, error.message);
+          return null;
+        }).process(async (id) => {
+          try {
+            return await this.get(id);
+          } catch (error) {
+            if (error.message.includes("Cipher job failed") || error.message.includes("OperationError")) {
+              console.warn(`Decryption failed for ${id}, returning basic info`);
+              return {
+                id,
+                _decryptionFailed: true,
+                _error: error.message
+              };
+            }
+            throw error;
+          }
+        });
+        const validResults2 = results2.filter((item) => item !== null);
+        this.emit("list", { partition, partitionValues, count: validResults2.length, errors: errors2.length });
+        return validResults2;
+      }
+      if (!this.config.partitions || !this.config.partitions[partition]) {
+        console.warn(`Partition '${partition}' not found in resource '${this.name}'`);
+        this.emit("list", { partition, partitionValues, count: 0, errors: 0 });
+        return [];
+      }
+      const partitionDef = this.config.partitions[partition];
+      const partitionSegments = [];
+      const sortedFields = Object.entries(partitionDef.fields).sort(([a], [b]) => a.localeCompare(b));
+      for (const [fieldName, rule] of sortedFields) {
+        const value = partitionValues[fieldName];
+        if (value !== void 0 && value !== null) {
+          const transformedValue = this.applyPartitionRule(value, rule);
+          partitionSegments.push(`${fieldName}=${transformedValue}`);
+        }
+      }
+      let prefix;
+      if (partitionSegments.length > 0) {
+        prefix = `resource=${this.name}/partition=${partition}/${partitionSegments.join("/")}`;
+      } else {
+        prefix = `resource=${this.name}/partition=${partition}`;
+      }
+      let keys = [];
+      try {
+        keys = await this.client.getAllKeys({ prefix });
+      } catch (getKeysError) {
+        console.warn(`Failed to get partition keys:`, getKeysError.message);
+        return [];
+      }
+      const ids = keys.map((key) => {
+        const parts = key.split("/");
+        const idPart = parts.find((part) => part.startsWith("id="));
+        return idPart ? idPart.replace("id=", "") : null;
+      }).filter(Boolean);
+      let filteredIds = ids.slice(offset);
       if (limit) {
-        filteredIds2 = filteredIds2.slice(0, limit);
+        filteredIds = filteredIds.slice(0, limit);
       }
-      const { results: results2, errors: errors2 } = await promisePool.PromisePool.for(filteredIds2).withConcurrency(this.parallelism).handleError(async (error, id) => {
-        console.warn(`Failed to get resource ${id}:`, error.message);
+      const { results, errors } = await promisePool.PromisePool.for(filteredIds).withConcurrency(this.parallelism).handleError(async (error, id) => {
+        console.warn(`Failed to get partition resource ${id}:`, error.message);
         return null;
       }).process(async (id) => {
         try {
-          return await this.get(id);
+          const keyForId = keys.find((key) => key.includes(`id=${id}`));
+          if (!keyForId) {
+            throw new Error(`Partition key not found for ID ${id}`);
+          }
+          const keyParts = keyForId.split("/");
+          const actualPartitionValues = {};
+          for (const [fieldName, rule] of sortedFields) {
+            const fieldPart = keyParts.find((part) => part.startsWith(`${fieldName}=`));
+            if (fieldPart) {
+              const value = fieldPart.replace(`${fieldName}=`, "");
+              actualPartitionValues[fieldName] = value;
+            }
+          }
+          return await this.getFromPartition({ id, partitionName: partition, partitionValues: actualPartitionValues });
         } catch (error) {
           if (error.message.includes("Cipher job failed") || error.message.includes("OperationError")) {
-            console.warn(`Decryption failed for ${id}, returning basic info`);
+            console.warn(`Decryption failed for partition resource ${id}, returning basic info`);
             return {
               id,
+              _partition: partition,
+              _partitionValues: partitionValues,
               _decryptionFailed: true,
               _error: error.message
             };
@@ -9888,62 +10002,19 @@ ${validation.errors.join("\n")}`);
           throw error;
         }
       });
-      const validResults2 = results2.filter((item) => item !== null);
-      this.emit("list", { partition, partitionValues, count: validResults2.length, errors: errors2.length });
-      return validResults2;
-    }
-    if (!this.config.partitions || !this.config.partitions[partition]) {
-      throw new Error(`Partition '${partition}' not found`);
-    }
-    const partitionDef = this.config.partitions[partition];
-    const partitionSegments = [];
-    const sortedFields = Object.entries(partitionDef.fields).sort(([a], [b]) => a.localeCompare(b));
-    for (const [fieldName, rule] of sortedFields) {
-      const value = partitionValues[fieldName];
-      if (value !== void 0 && value !== null) {
-        const transformedValue = this.applyPartitionRule(value, rule);
-        partitionSegments.push(`${fieldName}=${transformedValue}`);
+      const validResults = results.filter((item) => item !== null);
+      this.emit("list", { partition, partitionValues, count: validResults.length, errors: errors.length });
+      return validResults;
+    } catch (error) {
+      if (error.message.includes("Partition '") && error.message.includes("' not found")) {
+        console.warn(`Partition error in list method:`, error.message);
+        this.emit("list", { partition, partitionValues, count: 0, errors: 1 });
+        return [];
       }
+      console.error(`Critical error in list method:`, error.message);
+      this.emit("list", { partition, partitionValues, count: 0, errors: 1 });
+      return [];
     }
-    let prefix;
-    if (partitionSegments.length > 0) {
-      prefix = `resource=${this.name}/partition=${partition}/${partitionSegments.join("/")}`;
-    } else {
-      prefix = `resource=${this.name}/partition=${partition}`;
-    }
-    const keys = await this.client.getAllKeys({ prefix });
-    const ids = keys.map((key) => {
-      const parts = key.split("/");
-      const idPart = parts.find((part) => part.startsWith("id="));
-      return idPart ? idPart.replace("id=", "") : null;
-    }).filter(Boolean);
-    let filteredIds = ids.slice(offset);
-    if (limit) {
-      filteredIds = filteredIds.slice(0, limit);
-    }
-    const { results, errors } = await promisePool.PromisePool.for(filteredIds).withConcurrency(this.parallelism).handleError(async (error, id) => {
-      console.warn(`Failed to get partition resource ${id}:`, error.message);
-      return null;
-    }).process(async (id) => {
-      try {
-        return await this.getFromPartition({ id, partitionName: partition, partitionValues });
-      } catch (error) {
-        if (error.message.includes("Cipher job failed") || error.message.includes("OperationError")) {
-          console.warn(`Decryption failed for partition resource ${id}, returning basic info`);
-          return {
-            id,
-            _partition: partition,
-            _partitionValues: partitionValues,
-            _decryptionFailed: true,
-            _error: error.message
-          };
-        }
-        throw error;
-      }
-    });
-    const validResults = results.filter((item) => item !== null);
-    this.emit("list", { partition, partitionValues, count: validResults.length, errors: errors.length });
-    return validResults;
   }
   /**
    * Get multiple resources by their IDs
@@ -10050,36 +10121,67 @@ ${validation.errors.join("\n")}`);
    * console.log(`Got ${fastPage.items.length} items`); // totalItems will be null
    */
   async page({ offset = 0, size = 100, partition = null, partitionValues = {}, skipCount = false } = {}) {
-    let totalItems = null;
-    let totalPages = null;
-    if (!skipCount) {
-      totalItems = await this.count({ partition, partitionValues });
-      totalPages = Math.ceil(totalItems / size);
-    }
-    const page = Math.floor(offset / size);
-    const items = await this.list({
-      partition,
-      partitionValues,
-      limit: size,
-      offset
-    });
-    const result = {
-      items,
-      totalItems,
-      page,
-      pageSize: size,
-      totalPages,
-      // Add additional metadata for debugging
-      _debug: {
-        requestedSize: size,
-        requestedOffset: offset,
-        actualItemsReturned: items.length,
-        skipCount,
-        hasTotalItems: totalItems !== null
+    try {
+      let totalItems = null;
+      let totalPages = null;
+      if (!skipCount) {
+        try {
+          totalItems = await this.count({ partition, partitionValues });
+          totalPages = Math.ceil(totalItems / size);
+        } catch (countError) {
+          console.warn(`Failed to get count for page:`, countError.message);
+          totalItems = null;
+          totalPages = null;
+        }
       }
-    };
-    this.emit("page", result);
-    return result;
+      const page = Math.floor(offset / size);
+      let items = [];
+      try {
+        items = await this.list({
+          partition,
+          partitionValues,
+          limit: size,
+          offset
+        });
+      } catch (listError) {
+        console.warn(`Failed to get items for page:`, listError.message);
+        items = [];
+      }
+      const result = {
+        items,
+        totalItems,
+        page,
+        pageSize: size,
+        totalPages,
+        // Add additional metadata for debugging
+        _debug: {
+          requestedSize: size,
+          requestedOffset: offset,
+          actualItemsReturned: items.length,
+          skipCount,
+          hasTotalItems: totalItems !== null
+        }
+      };
+      this.emit("page", result);
+      return result;
+    } catch (error) {
+      console.error(`Critical error in page method:`, error.message);
+      return {
+        items: [],
+        totalItems: null,
+        page: Math.floor(offset / size),
+        pageSize: size,
+        totalPages: null,
+        _debug: {
+          requestedSize: size,
+          requestedOffset: offset,
+          actualItemsReturned: 0,
+          skipCount,
+          hasTotalItems: false,
+          error: error.message
+        }
+      };
+    }
   }
   readable() {
     const stream = new ResourceReader({ resource: this });
@@ -10372,7 +10474,118 @@ ${validation.errors.join("\n")}`);
     return results.slice(0, limit);
   }
   /**
-   * Update partition objects to keep them in sync
+   * Handle partition reference updates with change detection
+   * @param {Object} oldData - Original object data before update
+   * @param {Object} newData - Updated object data
+   */
+  async handlePartitionReferenceUpdates(oldData, newData) {
+    const partitions = this.config.partitions;
+    if (!partitions || Object.keys(partitions).length === 0) {
+      return;
+    }
+    for (const [partitionName, partition] of Object.entries(partitions)) {
+      try {
+        await this.handlePartitionReferenceUpdate(partitionName, partition, oldData, newData);
+      } catch (error) {
+        console.warn(`Failed to update partition references for ${partitionName}:`, error.message);
+      }
+    }
+    const id = newData.id || oldData.id;
+    for (const [partitionName, partition] of Object.entries(partitions)) {
+      const prefix = `resource=${this.name}/partition=${partitionName}`;
+      let allKeys = [];
+      try {
+        allKeys = await this.client.getAllKeys({ prefix });
+      } catch (error) {
+        console.warn(`Aggressive cleanup: could not list keys for partition ${partitionName}:`, error.message);
+        continue;
+      }
+      const validKey = this.getPartitionKey({ partitionName, id, data: newData });
+      for (const key of allKeys) {
+        if (key.endsWith(`/id=${id}`) && key !== validKey) {
+          try {
+            await this.client.deleteObject(key);
+          } catch (error) {
+            console.warn(`Aggressive cleanup: could not delete stale partition key ${key}:`, error.message);
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Handle partition reference update for a specific partition
+   * @param {string} partitionName - Name of the partition
+   * @param {Object} partition - Partition definition
+   * @param {Object} oldData - Original object data before update
+   * @param {Object} newData - Updated object data
+   */
+  async handlePartitionReferenceUpdate(partitionName, partition, oldData, newData) {
+    const id = newData.id || oldData.id;
+    const oldPartitionKey = this.getPartitionKey({ partitionName, id, data: oldData });
+    const newPartitionKey = this.getPartitionKey({ partitionName, id, data: newData });
+    if (oldPartitionKey !== newPartitionKey) {
+      if (oldPartitionKey) {
+        try {
+          await this.client.deleteObject(oldPartitionKey);
+        } catch (error) {
+          console.warn(`Old partition object could not be deleted for ${partitionName}:`, error.message);
+        }
+      }
+      if (newPartitionKey) {
+        try {
+          const mappedData = await this.schema.mapper(newData);
+          if (mappedData.undefined !== void 0) delete mappedData.undefined;
+          const behaviorImpl = getBehavior(this.behavior);
+          const { mappedData: processedMetadata, body } = await behaviorImpl.handleUpdate({
+            resource: this,
+            id,
+            data: newData,
+            mappedData
+          });
+          if (processedMetadata.undefined !== void 0) delete processedMetadata.undefined;
+          const partitionMetadata = {
+            ...processedMetadata,
+            _version: this.version
+          };
+          if (partitionMetadata.undefined !== void 0) delete partitionMetadata.undefined;
+          await this.client.putObject({
+            key: newPartitionKey,
+            metadata: partitionMetadata,
+            body
+          });
+        } catch (error) {
+          console.warn(`New partition object could not be created for ${partitionName}:`, error.message);
+        }
+      }
+    } else if (newPartitionKey) {
+      try {
+        const mappedData = await this.schema.mapper(newData);
+        if (mappedData.undefined !== void 0) delete mappedData.undefined;
+        const behaviorImpl = getBehavior(this.behavior);
+        const { mappedData: processedMetadata, body } = await behaviorImpl.handleUpdate({
+          resource: this,
+          id,
+          data: newData,
+          mappedData
+        });
+        if (processedMetadata.undefined !== void 0) delete processedMetadata.undefined;
+        const partitionMetadata = {
+          ...processedMetadata,
+          _version: this.version
+        };
+        if (partitionMetadata.undefined !== void 0) delete partitionMetadata.undefined;
+        await this.client.putObject({
+          key: newPartitionKey,
+          metadata: partitionMetadata,
+          body
+        });
+      } catch (error) {
+        console.warn(`Partition object could not be updated for ${partitionName}:`, error.message);
+      }
+    }
+  }
+  /**
+   * Update partition objects to keep them in sync (legacy method for backward compatibility)
    * @param {Object} data - Updated object data
    */
   async updatePartitionReferences(data) {
@@ -10381,6 +10594,10 @@ ${validation.errors.join("\n")}`);
       return;
     }
     for (const [partitionName, partition] of Object.entries(partitions)) {
+      if (!partition || !partition.fields || typeof partition.fields !== "object") {
+        console.warn(`Skipping invalid partition '${partitionName}' in resource '${this.name}'`);
+        continue;
+      }
       const partitionKey = this.getPartitionKey({ partitionName, id: data.id, data });
       if (partitionKey) {
         const mappedData = await this.schema.mapper(data);
@@ -10479,6 +10696,7 @@ ${validation.errors.join("\n")}`);
     if (request.VersionId) data._versionId = request.VersionId;
     if (request.Expiration) data._expiresAt = request.Expiration;
     data._definitionHash = this.getDefinitionHash();
+    if (data.undefined !== void 0) delete data.undefined;
     this.emit("getFromPartition", data);
     return data;
   }
@@ -10582,7 +10800,7 @@ class Database extends EventEmitter {
     this.version = "1";
     this.s3dbVersion = (() => {
       try {
-        return true ? "4.1.10" : "latest";
+        return true ? "5.0.0" : "latest";
       } catch (e) {
         return "latest";
       }
@@ -10597,14 +10815,24 @@ class Database extends EventEmitter {
     this.passphrase = options.passphrase || "secret";
     let connectionString = options.connectionString;
     if (!connectionString && (options.bucket || options.accessKeyId || options.secretAccessKey)) {
-      connectionString = ConnectionString.buildFromParams({
-        bucket: options.bucket,
-        region: options.region,
-        accessKeyId: options.accessKeyId,
-        secretAccessKey: options.secretAccessKey,
-        endpoint: options.endpoint,
-        forcePathStyle: options.forcePathStyle
-      });
+      const { bucket, region, accessKeyId, secretAccessKey, endpoint, forcePathStyle } = options;
+      if (endpoint) {
+        const url = new URL(endpoint);
+        if (accessKeyId) url.username = encodeURIComponent(accessKeyId);
+        if (secretAccessKey) url.password = encodeURIComponent(secretAccessKey);
+        url.pathname = `/${bucket || "s3db"}`;
+        if (forcePathStyle) {
+          url.searchParams.set("forcePathStyle", "true");
+        }
+        connectionString = url.toString();
+      } else if (accessKeyId && secretAccessKey) {
+        const params = new URLSearchParams();
+        params.set("region", region || "us-east-1");
+        if (forcePathStyle) {
+          params.set("forcePathStyle", "true");
+        }
+        connectionString = `s3://${encodeURIComponent(accessKeyId)}:${encodeURIComponent(secretAccessKey)}@${bucket || "s3db"}?${params.toString()}`;
+      }
     }
     this.client = options.client || new Client({
       verbose: this.verbose,
@@ -10640,12 +10868,12 @@ class Database extends EventEmitter {
           passphrase: this.passphrase,
           observers: [this],
           cache: this.cache,
-          timestamps: versionData.options?.timestamps || false,
-          partitions: resourceMetadata.partitions || versionData.options?.partitions || {},
-          paranoid: versionData.options?.paranoid !== false,
-          allNestedObjectsOptional: versionData.options?.allNestedObjectsOptional || false,
-          autoDecrypt: versionData.options?.autoDecrypt !== false,
-          hooks: {}
+          timestamps: versionData.timestamps !== void 0 ? versionData.timestamps : false,
+          partitions: resourceMetadata.partitions || versionData.partitions || {},
+          paranoid: versionData.paranoid !== void 0 ? versionData.paranoid : true,
+          allNestedObjectsOptional: versionData.allNestedObjectsOptional !== void 0 ? versionData.allNestedObjectsOptional : true,
+          autoDecrypt: versionData.autoDecrypt !== void 0 ? versionData.autoDecrypt : true,
+          hooks: versionData.hooks || {}
         });
       }
     }
@@ -10783,15 +11011,14 @@ class Database extends EventEmitter {
           [version]: {
             hash: definitionHash,
             attributes: resourceDef.attributes,
-            options: {
-              timestamps: resource.config.timestamps,
-              partitions: resource.config.partitions,
-              paranoid: resource.config.paranoid,
-              allNestedObjectsOptional: resource.config.allNestedObjectsOptional,
-              autoDecrypt: resource.config.autoDecrypt,
-              cache: resource.config.cache
-            },
             behavior: resourceDef.behavior || "user-management",
+            timestamps: resource.config.timestamps,
+            partitions: resource.config.partitions,
+            paranoid: resource.config.paranoid,
+            allNestedObjectsOptional: resource.config.allNestedObjectsOptional,
+            autoDecrypt: resource.config.autoDecrypt,
+            cache: resource.config.cache,
+            hooks: resource.config.hooks,
             createdAt: isNewVersion ? (/* @__PURE__ */ new Date()).toISOString() : existingVersionData?.createdAt
           }
         }
@@ -10826,73 +11053,58 @@ class Database extends EventEmitter {
   }
   /**
    * Check if a resource exists with the same definition hash
-   * @param {string} name - Resource name
-   * @param {Object} attributes - Resource attributes
-   * @param {Object} options - Resource options
-   * @param {string} behavior - Resource behavior
-   * @returns {Object} Object with exists flag and hash information
+   * @param {Object} config - Resource configuration
+   * @param {string} config.name - Resource name
+   * @param {Object} config.attributes - Resource attributes
+   * @param {string} [config.behavior] - Resource behavior
+   * @param {Object} [config.options] - Resource options (deprecated, use root level parameters)
+   * @returns {Object} Result with exists and hash information
    */
-  resourceExistsWithSameHash({ name, attributes, options = {}, behavior = "user-management" }) {
+  resourceExistsWithSameHash({ name, attributes, behavior = "user-management", options = {} }) {
     if (!this.resources[name]) {
       return { exists: false, sameHash: false, hash: null };
     }
-    const tempResource = new Resource({
+    const existingResource = this.resources[name];
+    const existingHash = this.generateDefinitionHash(existingResource.export());
+    const mockResource = new Resource({
       name,
       attributes,
       behavior,
-      observers: [],
       client: this.client,
-      version: "temp",
+      version: existingResource.version,
       passphrase: this.passphrase,
-      cache: this.cache,
       ...options
     });
-    const newHash = this.generateDefinitionHash(tempResource.export(), behavior);
-    const existingHash = this.generateDefinitionHash(this.resources[name].export(), this.resources[name].behavior);
+    const newHash = this.generateDefinitionHash(mockResource.export());
     return {
       exists: true,
-      sameHash: newHash === existingHash,
+      sameHash: existingHash === newHash,
       hash: newHash,
       existingHash
     };
   }
-  /**
-   * Create a resource only if it doesn't exist with the same definition hash
-   * @param {Object} params - Resource parameters
-   * @param {string} params.name - Resource name
-   * @param {Object} params.attributes - Resource attributes
-   * @param {Object} params.options - Resource options
-   * @param {string} params.behavior - Resource behavior
-   * @returns {Object} Object with resource and created flag
-   */
-  async createResourceIfNotExists({ name, attributes, options = {}, behavior = "user-management" }) {
-    const alreadyExists = !!this.resources[name];
-    const hashCheck = this.resourceExistsWithSameHash({ name, attributes, options, behavior });
-    if (hashCheck.exists && hashCheck.sameHash) {
-      return {
-        resource: this.resources[name],
-        created: false,
-        reason: "Resource already exists with same definition hash"
-      };
-    }
-    const resource = await this.createResource({ name, attributes, options, behavior });
-    return {
-      resource,
-      created: !alreadyExists,
-      reason: alreadyExists ? "Resource updated with new definition" : "New resource created"
-    };
-  }
-  async createResource({ name, attributes, options = {}, behavior = "user-management" }) {
+  async createResource({ name, attributes, behavior = "user-management", hooks, ...config }) {
     if (this.resources[name]) {
       const existingResource = this.resources[name];
       Object.assign(existingResource.config, {
         cache: this.cache,
-        ...options
+        ...config
       });
       if (behavior) {
         existingResource.behavior = behavior;
       }
       existingResource.updateAttributes(attributes);
+      if (hooks) {
+        for (const [event, hooksArr] of Object.entries(hooks)) {
+          if (Array.isArray(hooksArr) && existingResource.hooks[event]) {
+            for (const fn of hooksArr) {
+              if (typeof fn === "function") {
+                existingResource.hooks[event].push(fn.bind(existingResource));
+              }
+            }
+          }
+        }
+      }
       const newHash = this.generateDefinitionHash(existingResource.export(), existingResource.behavior);
       const existingMetadata2 = this.savedMetadata?.resources?.[name];
       const currentVersion = existingMetadata2?.currentVersion || "v0";
@@ -10914,7 +11126,8 @@ class Database extends EventEmitter {
       version,
       passphrase: this.passphrase,
       cache: this.cache,
-      ...options
+      hooks,
+      ...config
     });
     this.resources[name] = resource;
     await this.uploadMetadataFile();
@@ -17616,6 +17829,7 @@ class CachePlugin extends Plugin {
   }
 }
 
+exports.AVAILABLE_BEHAVIORS = AVAILABLE_BEHAVIORS;
 exports.AuthenticationError = AuthenticationError;
 exports.BaseError = BaseError;
 exports.Cache = Cache;
@@ -17623,6 +17837,7 @@ exports.CachePlugin = CachePlugin;
 exports.Client = Client;
 exports.ConnectionString = ConnectionString;
 exports.CostsPlugin = CostsPlugin;
+exports.DEFAULT_BEHAVIOR = DEFAULT_BEHAVIOR;
 exports.Database = Database;
 exports.DatabaseError = DatabaseError;
 exports.EncryptionError = EncryptionError;
@@ -17636,25 +17851,35 @@ exports.NotFound = NotFound;
 exports.PermissionError = PermissionError;
 exports.Plugin = Plugin;
 exports.PluginObject = PluginObject;
+exports.Resource = Resource;
 exports.ResourceIdsPageReader = ResourceIdsPageReader;
 exports.ResourceIdsReader = ResourceIdsReader;
 exports.ResourceNotFound = ResourceNotFound;
-exports.ResourceNotFoundError = ResourceNotFound;
 exports.ResourceReader = ResourceReader;
 exports.ResourceWriter = ResourceWriter;
 exports.S3Cache = S3Cache;
-exports.S3DB = S3db;
 exports.S3DBError = S3DBError;
 exports.S3_DEFAULT_ENDPOINT = S3_DEFAULT_ENDPOINT;
 exports.S3_DEFAULT_REGION = S3_DEFAULT_REGION;
 exports.S3db = S3db;
-exports.S3dbError = S3DBError;
+exports.Schema = Schema;
+exports.SchemaActions = SchemaActions;
 exports.UnknownError = UnknownError;
 exports.ValidationError = ValidationError;
 exports.Validator = Validator;
 exports.ValidatorManager = ValidatorManager;
+exports.behaviors = behaviors;
+exports.calculateAttributeNamesSize = calculateAttributeNamesSize;
+exports.calculateAttributeSizes = calculateAttributeSizes;
+exports.calculateTotalSize = calculateTotalSize;
+exports.calculateUTF8Bytes = calculateUTF8Bytes;
 exports.decrypt = decrypt;
 exports.default = S3db;
 exports.encrypt = encrypt;
+exports.getBehavior = getBehavior;
+exports.getSizeBreakdown = getSizeBreakdown;
+exports.idGenerator = idGenerator;
+exports.passwordGenerator = passwordGenerator;
 exports.sha256 = sha256;
 exports.streamToString = streamToString;
+exports.transformValue = transformValue;