s3db.js 4.1.14 → 5.1.0

package/dist/s3db.iife.js

@@ -237,7 +237,7 @@ var S3DB = (function (exports, nanoid, lodashEs, promisePool, clientS3, crypto,
 
   const idGenerator = nanoid.customAlphabet(nanoid.urlAlphabet, 22);
   const passwordAlphabet = "ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz23456789";
-  nanoid.customAlphabet(passwordAlphabet, 12);
+  const passwordGenerator = nanoid.customAlphabet(passwordAlphabet, 12);
 
   var domain;
 
@@ -3382,7 +3382,7 @@ ${JSON.stringify(validation, null, 2)}`, {
   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;
@@ -3395,6 +3395,10 @@ ${JSON.stringify(validation, null, 2)}`, {
     }
     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({}, {
@@ -3416,7 +3420,7 @@ ${JSON.stringify(validation, null, 2)}`, {
       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."
@@ -3424,11 +3428,15 @@ ${JSON.stringify(validation, null, 2)}`, {
       });
       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
       });
     }
   }
@@ -3440,10 +3448,31 @@ ${JSON.stringify(validation, null, 2)}`, {
     }
   });
 
+  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)) {
@@ -3534,8 +3563,9 @@ ${JSON.stringify(validation, null, 2)}`, {
         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() {
@@ -3576,24 +3606,27 @@ ${JSON.stringify(validation, null, 2)}`, {
         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) {
@@ -8608,7 +8641,6 @@ ${JSON.stringify(validation, null, 2)}`, {
   function calculateAttributeNamesSize(mappedObject) {
     let totalSize = 0;
     for (const key of Object.keys(mappedObject)) {
-      if (key === "_v") continue;
       totalSize += calculateUTF8Bytes(key);
     }
     return totalSize;
@@ -8652,6 +8684,30 @@ ${JSON.stringify(validation, null, 2)}`, {
     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 }) {
@@ -8872,6 +8928,7 @@ ${JSON.stringify(validation, null, 2)}`, {
     }
     return behavior;
   }
+  const AVAILABLE_BEHAVIORS = Object.keys(behaviors);
   const DEFAULT_BEHAVIOR = "user-management";
 
   class Resource extends EventEmitter {
@@ -8941,17 +8998,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;
@@ -8960,13 +9008,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: [],
@@ -8977,39 +9025,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]) {
@@ -9048,15 +9064,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 = {};
         }
@@ -9075,9 +9093,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: {
@@ -9085,8 +9104,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 };
     }
     /**
@@ -9174,7 +9201,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(", ")}.`
             );
           }
         }
@@ -9287,7 +9314,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
@@ -9516,12 +9547,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) {
@@ -9532,6 +9563,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({
@@ -9567,7 +9601,6 @@ ${validation.errors.join("\n")}`);
       });
       validated.id = id;
       await this.executeHooks("afterUpdate", validated);
-      await this.updatePartitionReferences(validated);
       this.emit("update", preProcessedData, validated);
       return validated;
     }
@@ -9854,23 +9887,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
               };
@@ -9878,62 +9992,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
@@ -10040,36 +10111,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 });
@@ -10362,7 +10464,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) {
@@ -10371,6 +10584,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);
@@ -10469,6 +10686,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;
     }
@@ -10572,7 +10790,7 @@ ${validation.errors.join("\n")}`);
       this.version = "1";
       this.s3dbVersion = (() => {
         try {
-          return true ? "4.1.10" : "latest";
+          return true ? "5.0.0" : "latest";
         } catch (e) {
           return "latest";
         }
@@ -10587,14 +10805,24 @@ ${validation.errors.join("\n")}`);
       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,
@@ -10630,12 +10858,12 @@ ${validation.errors.join("\n")}`);
             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 || {}
           });
         }
       }
@@ -10773,15 +11001,14 @@ ${validation.errors.join("\n")}`);
             [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
             }
           }
@@ -10816,73 +11043,58 @@ ${validation.errors.join("\n")}`);
     }
     /**
      * 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";
@@ -10904,7 +11116,8 @@ ${validation.errors.join("\n")}`);
         version,
         passphrase: this.passphrase,
         cache: this.cache,
-        ...options
+        hooks,
+        ...config
       });
       this.resources[name] = resource;
       await this.uploadMetadataFile();
@@ -17606,6 +17819,7 @@ ${validation.errors.join("\n")}`);
     }
   }
 
+  exports.AVAILABLE_BEHAVIORS = AVAILABLE_BEHAVIORS;
   exports.AuthenticationError = AuthenticationError;
   exports.BaseError = BaseError;
   exports.Cache = Cache;
@@ -17613,6 +17827,7 @@ ${validation.errors.join("\n")}`);
   exports.Client = Client;
   exports.ConnectionString = ConnectionString;
   exports.CostsPlugin = CostsPlugin;
+  exports.DEFAULT_BEHAVIOR = DEFAULT_BEHAVIOR;
   exports.Database = Database;
   exports.DatabaseError = DatabaseError;
   exports.EncryptionError = EncryptionError;
@@ -17626,28 +17841,38 @@ ${validation.errors.join("\n")}`);
   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;
 
   Object.defineProperty(exports, '__esModule', { value: true });