s3db.js 4.1.8 → 4.1.11

package/dist/s3db.cjs.js

@@ -1,6 +1,8 @@
 /* istanbul ignore file */
 'use strict';
 
+Object.defineProperty(exports, '__esModule', { value: true });
+
 var nanoid = require('nanoid');
 var lodashEs = require('lodash-es');
 var promisePool = require('@supercharge/promise-pool');
@@ -244,6 +246,8 @@ var substr = 'ab'.substr(-1) === 'b' ?
 ;
 
 const idGenerator = nanoid.customAlphabet(nanoid.urlAlphabet, 22);
+const passwordAlphabet = "ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz23456789";
+nanoid.customAlphabet(passwordAlphabet, 12);
 
 var domain;
 
@@ -744,42 +748,85 @@ ${JSON.stringify(rest, null, 2)}`;
     return `${this.name} | ${this.message}`;
   }
 }
-class NoSuchBucket extends BaseError {
+class S3DBError extends BaseError {
+  constructor(message, details = {}) {
+    super({ message, ...details });
+  }
+}
+class DatabaseError extends S3DBError {
+  constructor(message, details = {}) {
+    super(message, details);
+    Object.assign(this, details);
+  }
+}
+class ValidationError extends S3DBError {
+  constructor(message, details = {}) {
+    super(message, details);
+    Object.assign(this, details);
+  }
+}
+class AuthenticationError extends S3DBError {
+  constructor(message, details = {}) {
+    super(message, details);
+    Object.assign(this, details);
+  }
+}
+class PermissionError extends S3DBError {
+  constructor(message, details = {}) {
+    super(message, details);
+    Object.assign(this, details);
+  }
+}
+class EncryptionError extends S3DBError {
+  constructor(message, details = {}) {
+    super(message, details);
+    Object.assign(this, details);
+  }
+}
+class ResourceNotFound extends S3DBError {
+  constructor({ bucket, resourceName, id, ...rest }) {
+    super(`Resource not found: ${resourceName}/${id} [bucket:${bucket}]`, {
+      bucket,
+      resourceName,
+      id,
+      ...rest
+    });
+  }
+}
+class NoSuchBucket extends S3DBError {
   constructor({ bucket, ...rest }) {
-    super({ ...rest, bucket, message: `Bucket does not exists [bucket:${bucket}]` });
+    super(`Bucket does not exists [bucket:${bucket}]`, { bucket, ...rest });
   }
 }
-class NoSuchKey extends BaseError {
+class NoSuchKey extends S3DBError {
   constructor({ bucket, key, ...rest }) {
-    super({ ...rest, bucket, message: `Key [${key}] does not exists [bucket:${bucket}/${key}]` });
-    this.key = key;
+    super(`Key [${key}] does not exists [bucket:${bucket}/${key}]`, { bucket, key, ...rest });
   }
 }
 class NotFound extends NoSuchKey {
 }
-class MissingMetadata extends BaseError {
+class MissingMetadata extends S3DBError {
   constructor({ bucket, ...rest }) {
-    super({ ...rest, bucket, message: `Missing metadata for bucket [bucket:${bucket}]` });
+    super(`Missing metadata for bucket [bucket:${bucket}]`, { bucket, ...rest });
   }
 }
-class InvalidResourceItem extends BaseError {
+class InvalidResourceItem extends S3DBError {
   constructor({
     bucket,
     resourceName,
     attributes,
     validation
   }) {
-    super({
+    super(`This item is not valid. Resource=${resourceName} [bucket:${bucket}].
+${JSON.stringify(validation, null, 2)}`, {
       bucket,
-      message: `This item is not valid. Resource=${resourceName} [bucket:${bucket}].
-${JSON.stringify(validation, null, 2)}`
+      resourceName,
+      attributes,
+      validation
     });
-    this.resourceName = resourceName;
-    this.attributes = attributes;
-    this.validation = validation;
   }
 }
-class UnknownError extends BaseError {
+class UnknownError extends S3DBError {
 }
 const ErrorMap = {
   "NotFound": NotFound,
@@ -808,9 +855,9 @@ class ConnectionString {
     }
   }
   defineS3(uri) {
-    this.bucket = uri.hostname;
-    this.accessKeyId = uri.username;
-    this.secretAccessKey = uri.password;
+    this.bucket = decodeURIComponent(uri.hostname);
+    this.accessKeyId = decodeURIComponent(uri.username);
+    this.secretAccessKey = decodeURIComponent(uri.password);
     this.endpoint = S3_DEFAULT_ENDPOINT;
     if (["/", "", null].includes(uri.pathname)) {
       this.keyPrefix = "";
@@ -822,14 +869,14 @@ class ConnectionString {
   defineMinio(uri) {
     this.forcePathStyle = true;
     this.endpoint = uri.origin;
-    this.accessKeyId = uri.username;
-    this.secretAccessKey = uri.password;
+    this.accessKeyId = decodeURIComponent(uri.username);
+    this.secretAccessKey = decodeURIComponent(uri.password);
     if (["/", "", null].includes(uri.pathname)) {
       this.bucket = "s3db";
       this.keyPrefix = "";
     } else {
       let [, bucket, ...subpath] = uri.pathname.split("/");
-      this.bucket = bucket;
+      this.bucket = decodeURIComponent(bucket);
       this.keyPrefix = [...subpath || []].join("/");
     }
   }
@@ -8838,18 +8885,83 @@ function getBehavior(behaviorName) {
 const DEFAULT_BEHAVIOR = "user-management";
 
 class Resource extends EventEmitter {
-  constructor({
-    name,
-    client,
-    version = "1",
-    options = {},
-    attributes = {},
-    parallelism = 10,
-    passphrase = "secret",
-    observers = [],
-    behavior = DEFAULT_BEHAVIOR
-  }) {
+  /**
+   * Create a new Resource instance
+   * @param {Object} config - Resource configuration
+   * @param {string} config.name - Resource name
+   * @param {Object} config.client - S3 client instance
+   * @param {string} [config.version='v0'] - Resource version
+   * @param {Object} [config.attributes={}] - Resource attributes schema
+   * @param {string} [config.behavior='user-management'] - Resource behavior strategy
+   * @param {string} [config.passphrase='secret'] - Encryption passphrase
+   * @param {number} [config.parallelism=10] - Parallelism for bulk operations
+   * @param {Array} [config.observers=[]] - Observer instances
+   * @param {boolean} [config.cache=false] - Enable caching
+   * @param {boolean} [config.autoDecrypt=true] - Auto-decrypt secret fields
+   * @param {boolean} [config.timestamps=false] - Enable automatic timestamps
+   * @param {Object} [config.partitions={}] - Partition definitions
+   * @param {boolean} [config.paranoid=true] - Security flag for dangerous operations
+   * @param {boolean} [config.allNestedObjectsOptional=false] - Make nested objects optional
+   * @param {Object} [config.hooks={}] - Custom hooks
+   * @param {Object} [config.options={}] - Additional options
+   * @example
+   * const users = new Resource({
+   *   name: 'users',
+   *   client: s3Client,
+   *   attributes: {
+   *     name: 'string|required',
+   *     email: 'string|required',
+   *     password: 'secret|required'
+   *   },
+   *   behavior: 'user-management',
+   *   passphrase: 'my-secret-key',
+   *   timestamps: true,
+   *   partitions: {
+   *     byRegion: {
+   *       fields: { region: 'string' }
+   *     }
+   *   },
+   *   hooks: {
+   *     preInsert: [async (data) => {
+   *       console.log('Pre-insert hook:', data);
+   *       return data;
+   *     }]
+   *   }
+   * });
+   */
+  constructor(config) {
     super();
+    const validation = validateResourceConfig(config);
+    if (!validation.isValid) {
+      throw new Error(`Invalid Resource configuration:
+${validation.errors.join("\n")}`);
+    }
+    const {
+      name,
+      client,
+      version = "1",
+      attributes = {},
+      behavior = DEFAULT_BEHAVIOR,
+      passphrase = "secret",
+      parallelism = 10,
+      observers = [],
+      cache = false,
+      autoDecrypt = true,
+      timestamps = false,
+      partitions = {},
+      paranoid = true,
+      allNestedObjectsOptional = true,
+      hooks = {},
+      options = {}
+    } = 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;
@@ -8857,15 +8969,14 @@ class Resource extends EventEmitter {
     this.observers = observers;
     this.parallelism = parallelism;
     this.passphrase = passphrase ?? "secret";
-    this.options = {
-      cache: false,
-      autoDecrypt: true,
-      timestamps: false,
-      partitions: {},
-      paranoid: true,
-      // Security flag for dangerous operations
-      allNestedObjectsOptional: options.allNestedObjectsOptional ?? false,
-      ...options
+    this.config = {
+      cache: mergedOptions.cache,
+      hooks,
+      paranoid: mergedOptions.paranoid,
+      timestamps: mergedOptions.timestamps,
+      partitions: mergedOptions.partitions,
+      autoDecrypt: mergedOptions.autoDecrypt,
+      allNestedObjectsOptional: mergedOptions.allNestedObjectsOptional
     };
     this.hooks = {
       preInsert: [],
@@ -8876,18 +8987,21 @@ class Resource extends EventEmitter {
       afterDelete: []
     };
     this.attributes = attributes || {};
-    if (options.timestamps) {
+    if (this.config.timestamps) {
       this.attributes.createdAt = "string|optional";
       this.attributes.updatedAt = "string|optional";
-      if (!this.options.partitions.byCreatedDate) {
-        this.options.partitions.byCreatedDate = {
+      if (!this.config.partitions) {
+        this.config.partitions = {};
+      }
+      if (!this.config.partitions.byCreatedDate) {
+        this.config.partitions.byCreatedDate = {
           fields: {
             createdAt: "date|maxlength:10"
           }
         };
       }
-      if (!this.options.partitions.byUpdatedDate) {
-        this.options.partitions.byUpdatedDate = {
+      if (!this.config.partitions.byUpdatedDate) {
+        this.config.partitions.byUpdatedDate = {
           fields: {
             updatedAt: "date|maxlength:10"
           }
@@ -8900,25 +9014,47 @@ class Resource extends EventEmitter {
       passphrase,
       version: this.version,
       options: {
-        ...this.options,
-        allNestedObjectsOptional: this.options.allNestedObjectsOptional ?? false
+        autoDecrypt: this.config.autoDecrypt,
+        allNestedObjectsOptional: this.config.allNestedObjectsOptional
       }
     });
-    this.validatePartitions();
     this.setupPartitionHooks();
-    if (options.hooks) {
-      for (const [event, hooksArr] of Object.entries(options.hooks)) {
+    this.validatePartitions();
+    if (hooks) {
+      for (const [event, hooksArr] of Object.entries(hooks)) {
         if (Array.isArray(hooksArr) && this.hooks[event]) {
           for (const fn of hooksArr) {
-            this.hooks[event].push(fn.bind(this));
+            if (typeof fn === "function") {
+              this.hooks[event].push(fn.bind(this));
+            }
           }
         }
       }
     }
   }
+  /**
+   * Get resource options (for backward compatibility with tests)
+   */
+  get options() {
+    return {
+      timestamps: this.config.timestamps,
+      partitions: this.config.partitions || {},
+      cache: this.config.cache,
+      autoDecrypt: this.config.autoDecrypt,
+      paranoid: this.config.paranoid,
+      allNestedObjectsOptional: this.config.allNestedObjectsOptional
+    };
+  }
   export() {
     const exported = this.schema.export();
     exported.behavior = this.behavior;
+    exported.timestamps = this.config.timestamps;
+    exported.partitions = this.config.partitions || {};
+    exported.paranoid = this.config.paranoid;
+    exported.allNestedObjectsOptional = this.config.allNestedObjectsOptional;
+    exported.autoDecrypt = this.config.autoDecrypt;
+    exported.cache = this.config.cache;
+    exported.hooks = this.hooks;
     return exported;
   }
   /**
@@ -8928,18 +9064,21 @@ class Resource extends EventEmitter {
   updateAttributes(newAttributes) {
     const oldAttributes = this.attributes;
     this.attributes = newAttributes;
-    if (this.options.timestamps) {
+    if (this.config.timestamps) {
       newAttributes.createdAt = "string|optional";
       newAttributes.updatedAt = "string|optional";
-      if (!this.options.partitions.byCreatedDate) {
-        this.options.partitions.byCreatedDate = {
+      if (!this.config.partitions) {
+        this.config.partitions = {};
+      }
+      if (!this.config.partitions.byCreatedDate) {
+        this.config.partitions.byCreatedDate = {
           fields: {
             createdAt: "date|maxlength:10"
           }
         };
       }
-      if (!this.options.partitions.byUpdatedDate) {
-        this.options.partitions.byUpdatedDate = {
+      if (!this.config.partitions.byUpdatedDate) {
+        this.config.partitions.byUpdatedDate = {
           fields: {
             updatedAt: "date|maxlength:10"
           }
@@ -8951,10 +9090,13 @@ class Resource extends EventEmitter {
       attributes: newAttributes,
       passphrase: this.passphrase,
       version: this.version,
-      options: this.options
+      options: {
+        autoDecrypt: this.config.autoDecrypt,
+        allNestedObjectsOptional: this.config.allNestedObjectsOptional
+      }
     });
-    this.validatePartitions();
     this.setupPartitionHooks();
+    this.validatePartitions();
     return { oldAttributes, newAttributes };
   }
   /**
@@ -8985,15 +9127,24 @@ class Resource extends EventEmitter {
    * Setup automatic partition hooks
    */
   setupPartitionHooks() {
-    const partitions = this.options.partitions;
-    if (!partitions || Object.keys(partitions).length === 0) {
+    if (!this.config.partitions) {
+      return;
+    }
+    const partitions = this.config.partitions;
+    if (Object.keys(partitions).length === 0) {
       return;
     }
-    this.addHook("afterInsert", async (data) => {
+    if (!this.hooks.afterInsert) {
+      this.hooks.afterInsert = [];
+    }
+    this.hooks.afterInsert.push(async (data) => {
       await this.createPartitionReferences(data);
       return data;
     });
-    this.addHook("afterDelete", async (data) => {
+    if (!this.hooks.afterDelete) {
+      this.hooks.afterDelete = [];
+    }
+    this.hooks.afterDelete.push(async (data) => {
       await this.deletePartitionReferences(data);
       return data;
     });
@@ -9018,8 +9169,11 @@ class Resource extends EventEmitter {
    * @throws {Error} If partition fields don't exist in current schema
    */
   validatePartitions() {
-    const partitions = this.options.partitions;
-    if (!partitions || Object.keys(partitions).length === 0) {
+    if (!this.config.partitions) {
+      return;
+    }
+    const partitions = this.config.partitions;
+    if (Object.keys(partitions).length === 0) {
       return;
     }
     const currentAttributes = Object.keys(this.attributes || {});
@@ -9126,10 +9280,10 @@ class Resource extends EventEmitter {
    * // Returns: null
    */
   getPartitionKey({ partitionName, id, data }) {
-    const partition = this.options.partitions[partitionName];
-    if (!partition) {
+    if (!this.config.partitions || !this.config.partitions[partitionName]) {
       throw new Error(`Partition '${partitionName}' not found`);
     }
+    const partition = this.config.partitions[partitionName];
     const partitionSegments = [];
     const sortedFields = Object.entries(partition.fields).sort(([a], [b]) => a.localeCompare(b));
     for (const [fieldName, rule] of sortedFields) {
@@ -9185,6 +9339,12 @@ class Resource extends EventEmitter {
    *   name: 'Jane Smith',
    *   email: 'jane@example.com'
    * });
+   * 
+   * // Insert with auto-generated password for secret field
+   * const user = await resource.insert({
+   *   name: 'John Doe',
+   *   email: 'john@example.com',
+   * });
    */
   async insert({ id, ...attributes }) {
     if (this.options.timestamps) {
@@ -9269,6 +9429,58 @@ class Resource extends EventEmitter {
       this.emit("get", data);
       return data;
     } catch (error) {
+      if (error.message.includes("Cipher job failed") || error.message.includes("OperationError") || error.originalError?.message?.includes("Cipher job failed")) {
+        try {
+          console.warn(`Decryption failed for resource ${id}, attempting to get raw metadata`);
+          const request = await this.client.headObject(key);
+          const objectVersion = this.extractVersionFromKey(key) || this.version;
+          const tempSchema = new Schema({
+            name: this.name,
+            attributes: this.attributes,
+            passphrase: this.passphrase,
+            version: objectVersion,
+            options: {
+              ...this.config,
+              autoDecrypt: false,
+              // Disable decryption
+              autoEncrypt: false
+              // Disable encryption
+            }
+          });
+          let metadata = await tempSchema.unmapper(request.Metadata);
+          const behaviorImpl = getBehavior(this.behavior);
+          let body = "";
+          if (request.ContentLength > 0) {
+            try {
+              const fullObject = await this.client.getObject(key);
+              body = await streamToString(fullObject.Body);
+            } catch (bodyError) {
+              console.warn(`Failed to read body for resource ${id}:`, bodyError.message);
+              body = "";
+            }
+          }
+          const { metadata: processedMetadata } = await behaviorImpl.handleGet({
+            resource: this,
+            metadata,
+            body
+          });
+          let data = processedMetadata;
+          data.id = id;
+          data._contentLength = request.ContentLength;
+          data._lastModified = request.LastModified;
+          data._hasContent = request.ContentLength > 0;
+          data._mimeType = request.ContentType || null;
+          data._version = objectVersion;
+          data._decryptionFailed = true;
+          if (request.VersionId) data._versionId = request.VersionId;
+          if (request.Expiration) data._expiresAt = request.Expiration;
+          data._definitionHash = this.getDefinitionHash();
+          this.emit("get", data);
+          return data;
+        } catch (fallbackError) {
+          console.error(`Fallback attempt also failed for resource ${id}:`, fallbackError.message);
+        }
+      }
       const enhancedError = new Error(`Failed to get resource with id '${id}': ${error.message}`);
       enhancedError.originalError = error;
       enhancedError.resourceId = id;
@@ -9315,7 +9527,7 @@ class Resource extends EventEmitter {
    */
   async update(id, attributes) {
     const live = await this.get(id);
-    if (this.options.timestamps) {
+    if (this.config.timestamps) {
       attributes.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     }
     const preProcessedData = await this.executeHooks("preUpdate", attributes);
@@ -9437,7 +9649,7 @@ class Resource extends EventEmitter {
   async count({ partition = null, partitionValues = {} } = {}) {
     let prefix;
     if (partition && Object.keys(partitionValues).length > 0) {
-      const partitionDef = this.options.partitions[partition];
+      const partitionDef = this.config.partitions[partition];
       if (!partitionDef) {
         throw new Error(`Partition '${partition}' not found`);
       }
@@ -9522,9 +9734,9 @@ class Resource extends EventEmitter {
     return results;
   }
   async deleteAll() {
-    if (this.options.paranoid !== false) {
+    if (this.config.paranoid !== false) {
       throw new Error(
-        `deleteAll() is a dangerous operation and requires paranoid: false option. Current paranoid setting: ${this.options.paranoid}`
+        `deleteAll() is a dangerous operation and requires paranoid: false option. Current paranoid setting: ${this.config.paranoid}`
       );
     }
     const prefix = `resource=${this.name}/v=${this.version}`;
@@ -9541,9 +9753,9 @@ class Resource extends EventEmitter {
    * @returns {Promise<Object>} Deletion report
    */
   async deleteAllData() {
-    if (this.options.paranoid !== false) {
+    if (this.config.paranoid !== false) {
       throw new Error(
-        `deleteAllData() is a dangerous operation and requires paranoid: false option. Current paranoid setting: ${this.options.paranoid}`
+        `deleteAllData() is a dangerous operation and requires paranoid: false option. Current paranoid setting: ${this.config.paranoid}`
       );
     }
     const prefix = `resource=${this.name}`;
@@ -9586,10 +9798,10 @@ class Resource extends EventEmitter {
   async listIds({ partition = null, partitionValues = {}, limit, offset = 0 } = {}) {
     let prefix;
     if (partition && Object.keys(partitionValues).length > 0) {
-      const partitionDef = this.options.partitions[partition];
-      if (!partitionDef) {
+      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) {
@@ -9658,16 +9870,32 @@ class Resource extends EventEmitter {
       if (limit) {
         filteredIds2 = filteredIds2.slice(0, limit);
       }
-      const { results: results2 } = await promisePool.PromisePool.for(filteredIds2).withConcurrency(this.parallelism).process(async (id) => {
-        return await this.get(id);
+      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;
+        }
       });
-      this.emit("list", { partition, partitionValues, count: results2.length });
-      return results2;
+      const validResults2 = results2.filter((item) => item !== null);
+      this.emit("list", { partition, partitionValues, count: validResults2.length, errors: errors2.length });
+      return validResults2;
     }
-    const partitionDef = this.options.partitions[partition];
-    if (!partitionDef) {
+    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) {
@@ -9693,11 +9921,29 @@ class Resource extends EventEmitter {
     if (limit) {
       filteredIds = filteredIds.slice(0, limit);
     }
-    const { results } = await promisePool.PromisePool.for(filteredIds).withConcurrency(this.parallelism).process(async (id) => {
-      return await this.getFromPartition({ id, partitionName: partition, partitionValues });
+    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;
+      }
     });
-    this.emit("list", { partition, partitionValues, count: results.length });
-    return results;
+    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
@@ -9708,11 +9954,30 @@ class Resource extends EventEmitter {
    * users.forEach(user => console.log(user.name));
    */
   async getMany(ids) {
-    const { results } = await promisePool.PromisePool.for(ids).withConcurrency(this.client.parallelism).process(async (id) => {
+    const { results, errors } = await promisePool.PromisePool.for(ids).withConcurrency(this.client.parallelism).handleError(async (error, id) => {
+      console.warn(`Failed to get resource ${id}:`, error.message);
+      return {
+        id,
+        _error: error.message,
+        _decryptionFailed: error.message.includes("Cipher job failed") || error.message.includes("OperationError")
+      };
+    }).process(async (id) => {
       this.emit("id", id);
-      const data = await this.get(id);
-      this.emit("data", data);
-      return data;
+      try {
+        const data = await this.get(id);
+        this.emit("data", data);
+        return data;
+      } 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;
+      }
     });
     this.emit("getMany", ids.length);
     return results;
@@ -9727,9 +9992,28 @@ class Resource extends EventEmitter {
   async getAll() {
     let ids = await this.listIds();
     if (ids.length === 0) return [];
-    const { results } = await promisePool.PromisePool.for(ids).withConcurrency(this.client.parallelism).process(async (id) => {
-      const data = await this.get(id);
-      return data;
+    const { results, errors } = await promisePool.PromisePool.for(ids).withConcurrency(this.client.parallelism).handleError(async (error, id) => {
+      console.warn(`Failed to get resource ${id}:`, error.message);
+      return {
+        id,
+        _error: error.message,
+        _decryptionFailed: error.message.includes("Cipher job failed") || error.message.includes("OperationError")
+      };
+    }).process(async (id) => {
+      try {
+        const data = await this.get(id);
+        return data;
+      } 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;
+      }
     });
     this.emit("getAll", results.length);
     return results;
@@ -9916,16 +10200,14 @@ class Resource extends EventEmitter {
   }
   /**
    * Generate definition hash for this resource
-   * @returns {string} SHA256 hash of the schema definition
+   * @returns {string} SHA256 hash of the resource definition (name + attributes)
    */
   getDefinitionHash() {
-    const attributes = this.schema.export().attributes;
-    const stableAttributes = { ...attributes };
-    if (this.options.timestamps) {
-      delete stableAttributes.createdAt;
-      delete stableAttributes.updatedAt;
-    }
-    const stableString = jsonStableStringify(stableAttributes);
+    const definition = {
+      attributes: this.attributes,
+      behavior: this.behavior
+    };
+    const stableString = jsonStableStringify(definition);
     return `sha256:${crypto.createHash("sha256").update(stableString).digest("hex")}`;
   }
   /**
@@ -9944,14 +10226,34 @@ class Resource extends EventEmitter {
    * @returns {Object} Schema object for the version
    */
   async getSchemaForVersion(version) {
-    return this.schema;
+    if (version === this.version) {
+      return this.schema;
+    }
+    try {
+      const compatibleSchema = new Schema({
+        name: this.name,
+        attributes: this.attributes,
+        passphrase: this.passphrase,
+        version,
+        options: {
+          ...this.config,
+          // For older versions, be more lenient with decryption
+          autoDecrypt: true,
+          autoEncrypt: true
+        }
+      });
+      return compatibleSchema;
+    } catch (error) {
+      console.warn(`Failed to create compatible schema for version ${version}, using current schema:`, error.message);
+      return this.schema;
+    }
   }
   /**
    * Create partition references after insert
    * @param {Object} data - Inserted object data
    */
   async createPartitionReferences(data) {
-    const partitions = this.options.partitions;
+    const partitions = this.config.partitions;
     if (!partitions || Object.keys(partitions).length === 0) {
       return;
     }
@@ -9982,7 +10284,7 @@ class Resource extends EventEmitter {
    * @param {Object} data - Deleted object data
    */
   async deletePartitionReferences(data) {
-    const partitions = this.options.partitions;
+    const partitions = this.config.partitions;
     if (!partitions || Object.keys(partitions).length === 0) {
       return;
     }
@@ -10074,7 +10376,7 @@ class Resource extends EventEmitter {
    * @param {Object} data - Updated object data
    */
   async updatePartitionReferences(data) {
-    const partitions = this.options.partitions;
+    const partitions = this.config.partitions;
     if (!partitions || Object.keys(partitions).length === 0) {
       return;
     }
@@ -10130,10 +10432,10 @@ class Resource extends EventEmitter {
    * });
    */
   async getFromPartition({ id, partitionName, partitionValues = {} }) {
-    const partition = this.options.partitions[partitionName];
-    if (!partition) {
+    if (!this.config.partitions || !this.config.partitions[partitionName]) {
       throw new Error(`Partition '${partitionName}' not found`);
     }
+    const partition = this.config.partitions[partitionName];
     const partitionSegments = [];
     const sortedFields = Object.entries(partition.fields).sort(([a], [b]) => a.localeCompare(b));
     for (const [fieldName, rule] of sortedFields) {
@@ -10181,6 +10483,98 @@ class Resource extends EventEmitter {
     return data;
   }
 }
+function validateResourceConfig(config) {
+  const errors = [];
+  if (!config.name) {
+    errors.push("Resource 'name' is required");
+  } else if (typeof config.name !== "string") {
+    errors.push("Resource 'name' must be a string");
+  } else if (config.name.trim() === "") {
+    errors.push("Resource 'name' cannot be empty");
+  }
+  if (!config.client) {
+    errors.push("S3 'client' is required");
+  }
+  if (!config.attributes) {
+    errors.push("Resource 'attributes' are required");
+  } else if (typeof config.attributes !== "object" || Array.isArray(config.attributes)) {
+    errors.push("Resource 'attributes' must be an object");
+  } else if (Object.keys(config.attributes).length === 0) {
+    errors.push("Resource 'attributes' cannot be empty");
+  }
+  if (config.version !== void 0 && typeof config.version !== "string") {
+    errors.push("Resource 'version' must be a string");
+  }
+  if (config.behavior !== void 0 && typeof config.behavior !== "string") {
+    errors.push("Resource 'behavior' must be a string");
+  }
+  if (config.passphrase !== void 0 && typeof config.passphrase !== "string") {
+    errors.push("Resource 'passphrase' must be a string");
+  }
+  if (config.parallelism !== void 0) {
+    if (typeof config.parallelism !== "number" || !Number.isInteger(config.parallelism)) {
+      errors.push("Resource 'parallelism' must be an integer");
+    } else if (config.parallelism < 1) {
+      errors.push("Resource 'parallelism' must be greater than 0");
+    }
+  }
+  if (config.observers !== void 0 && !Array.isArray(config.observers)) {
+    errors.push("Resource 'observers' must be an array");
+  }
+  const booleanFields = ["cache", "autoDecrypt", "timestamps", "paranoid", "allNestedObjectsOptional"];
+  for (const field of booleanFields) {
+    if (config[field] !== void 0 && typeof config[field] !== "boolean") {
+      errors.push(`Resource '${field}' must be a boolean`);
+    }
+  }
+  if (config.partitions !== void 0) {
+    if (typeof config.partitions !== "object" || Array.isArray(config.partitions)) {
+      errors.push("Resource 'partitions' must be an object");
+    } else {
+      for (const [partitionName, partitionDef] of Object.entries(config.partitions)) {
+        if (typeof partitionDef !== "object" || Array.isArray(partitionDef)) {
+          errors.push(`Partition '${partitionName}' must be an object`);
+        } else if (!partitionDef.fields) {
+          errors.push(`Partition '${partitionName}' must have a 'fields' property`);
+        } else if (typeof partitionDef.fields !== "object" || Array.isArray(partitionDef.fields)) {
+          errors.push(`Partition '${partitionName}.fields' must be an object`);
+        } else {
+          for (const [fieldName, fieldType] of Object.entries(partitionDef.fields)) {
+            if (typeof fieldType !== "string") {
+              errors.push(`Partition '${partitionName}.fields.${fieldName}' must be a string`);
+            }
+          }
+        }
+      }
+    }
+  }
+  if (config.hooks !== void 0) {
+    if (typeof config.hooks !== "object" || Array.isArray(config.hooks)) {
+      errors.push("Resource 'hooks' must be an object");
+    } else {
+      const validHookEvents = ["preInsert", "afterInsert", "preUpdate", "afterUpdate", "preDelete", "afterDelete"];
+      for (const [event, hooksArr] of Object.entries(config.hooks)) {
+        if (!validHookEvents.includes(event)) {
+          errors.push(`Invalid hook event '${event}'. Valid events: ${validHookEvents.join(", ")}`);
+        } else if (!Array.isArray(hooksArr)) {
+          errors.push(`Resource 'hooks.${event}' must be an array`);
+        } else {
+          for (let i = 0; i < hooksArr.length; i++) {
+            const hook = hooksArr[i];
+            if (typeof hook !== "function") {
+              if (typeof hook === "string") continue;
+              continue;
+            }
+          }
+        }
+      }
+    }
+  }
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+}
 
 class Database extends EventEmitter {
   constructor(options) {
@@ -10188,7 +10582,7 @@ class Database extends EventEmitter {
     this.version = "1";
     this.s3dbVersion = (() => {
       try {
-        return true ? "4.1.7" : "latest";
+        return true ? "4.1.10" : "latest";
       } catch (e) {
         return "latest";
       }
@@ -10201,10 +10595,21 @@ class Database extends EventEmitter {
     this.plugins = options.plugins || [];
     this.cache = options.cache;
     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
+      });
+    }
     this.client = options.client || new Client({
       verbose: this.verbose,
       parallelism: this.parallelism,
-      connectionString: options.connectionString
+      connectionString
     });
     this.bucket = this.client.bucket;
     this.keyPrefix = this.client.keyPrefix;
@@ -10229,15 +10634,18 @@ class Database extends EventEmitter {
           name,
           client: this.client,
           version: currentVersion,
-          options: {
-            ...versionData.options,
-            partitions: resourceMetadata.partitions || versionData.options?.partitions || {}
-          },
           attributes: versionData.attributes,
           behavior: versionData.behavior || "user-management",
           parallelism: this.parallelism,
           passphrase: this.passphrase,
-          observers: [this]
+          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: {}
         });
       }
     }
@@ -10306,7 +10714,7 @@ class Database extends EventEmitter {
   generateDefinitionHash(definition, behavior = void 0) {
     const attributes = definition.attributes;
     const stableAttributes = { ...attributes };
-    if (definition.options?.timestamps) {
+    if (definition.timestamps) {
       delete stableAttributes.createdAt;
       delete stableAttributes.updatedAt;
     }
@@ -10368,14 +10776,21 @@ class Database extends EventEmitter {
       }
       metadata.resources[name] = {
         currentVersion: version,
-        partitions: resourceDef.options?.partitions || {},
+        partitions: resource.config.partitions || {},
         versions: {
           ...existingResource?.versions,
           // Preserve previous versions
           [version]: {
             hash: definitionHash,
             attributes: resourceDef.attributes,
-            options: resourceDef.options,
+            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",
             createdAt: isNewVersion ? (/* @__PURE__ */ new Date()).toISOString() : existingVersionData?.createdAt
           }
@@ -10428,10 +10843,9 @@ class Database extends EventEmitter {
       observers: [],
       client: this.client,
       version: "temp",
-      options: {
-        cache: this.cache,
-        ...options
-      }
+      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);
@@ -10471,7 +10885,7 @@ class Database extends EventEmitter {
   async createResource({ name, attributes, options = {}, behavior = "user-management" }) {
     if (this.resources[name]) {
       const existingResource = this.resources[name];
-      Object.assign(existingResource.options, {
+      Object.assign(existingResource.config, {
         cache: this.cache,
         ...options
       });
@@ -10498,10 +10912,9 @@ class Database extends EventEmitter {
       observers: [this],
       client: this.client,
       version,
-      options: {
-        cache: this.cache,
-        ...options
-      }
+      passphrase: this.passphrase,
+      cache: this.cache,
+      ...options
     });
     this.resources[name] = resource;
     await this.uploadMetadataFile();
@@ -17203,6 +17616,7 @@ class CachePlugin extends Plugin {
   }
 }
 
+exports.AuthenticationError = AuthenticationError;
 exports.BaseError = BaseError;
 exports.Cache = Cache;
 exports.CachePlugin = CachePlugin;
@@ -17210,6 +17624,8 @@ exports.Client = Client;
 exports.ConnectionString = ConnectionString;
 exports.CostsPlugin = CostsPlugin;
 exports.Database = Database;
+exports.DatabaseError = DatabaseError;
+exports.EncryptionError = EncryptionError;
 exports.ErrorMap = ErrorMap;
 exports.InvalidResourceItem = InvalidResourceItem;
 exports.MemoryCache = MemoryCache;
@@ -17217,20 +17633,28 @@ exports.MissingMetadata = MissingMetadata;
 exports.NoSuchBucket = NoSuchBucket;
 exports.NoSuchKey = NoSuchKey;
 exports.NotFound = NotFound;
+exports.PermissionError = PermissionError;
 exports.Plugin = Plugin;
 exports.PluginObject = PluginObject;
 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.UnknownError = UnknownError;
+exports.ValidationError = ValidationError;
 exports.Validator = Validator;
 exports.ValidatorManager = ValidatorManager;
 exports.decrypt = decrypt;
+exports.default = S3db;
 exports.encrypt = encrypt;
 exports.sha256 = sha256;
 exports.streamToString = streamToString;