s3db.js 12.3.0 → 12.4.0

package/dist/s3db.cjs.js

@@ -13447,7 +13447,7 @@ function generateMySQLAlterTable(tableName, attributes, existingSchema) {
   }
   return alterStatements;
 }
-function generateBigQuerySchema(attributes) {
+function generateBigQuerySchema(attributes, mutability = "append-only") {
   const fields = [];
   fields.push({
     name: "id",
@@ -13471,6 +13471,14 @@ function generateBigQuerySchema(attributes) {
   if (!attributes.updatedAt) {
     fields.push({ name: "updated_at", type: "TIMESTAMP", mode: "NULLABLE" });
   }
+  if (mutability === "append-only" || mutability === "immutable") {
+    fields.push({ name: "_operation_type", type: "STRING", mode: "NULLABLE" });
+    fields.push({ name: "_operation_timestamp", type: "TIMESTAMP", mode: "NULLABLE" });
+  }
+  if (mutability === "immutable") {
+    fields.push({ name: "_is_deleted", type: "BOOL", mode: "NULLABLE" });
+    fields.push({ name: "_version", type: "INT64", mode: "NULLABLE" });
+  }
   return fields;
 }
 async function getBigQueryTableSchema(bigqueryClient, datasetId, tableId) {
@@ -13492,7 +13500,7 @@ async function getBigQueryTableSchema(bigqueryClient, datasetId, tableId) {
   }
   return schema;
 }
-function generateBigQuerySchemaUpdate(attributes, existingSchema) {
+function generateBigQuerySchemaUpdate(attributes, existingSchema, mutability = "append-only") {
   const newFields = [];
   for (const [fieldName, fieldConfig] of Object.entries(attributes)) {
     if (fieldName === "id") continue;
@@ -13506,6 +13514,22 @@ function generateBigQuerySchemaUpdate(attributes, existingSchema) {
       mode: required ? "REQUIRED" : "NULLABLE"
     });
   }
+  if (mutability === "append-only" || mutability === "immutable") {
+    if (!existingSchema["_operation_type"]) {
+      newFields.push({ name: "_operation_type", type: "STRING", mode: "NULLABLE" });
+    }
+    if (!existingSchema["_operation_timestamp"]) {
+      newFields.push({ name: "_operation_timestamp", type: "TIMESTAMP", mode: "NULLABLE" });
+    }
+  }
+  if (mutability === "immutable") {
+    if (!existingSchema["_is_deleted"]) {
+      newFields.push({ name: "_is_deleted", type: "BOOL", mode: "NULLABLE" });
+    }
+    if (!existingSchema["_version"]) {
+      newFields.push({ name: "_version", type: "INT64", mode: "NULLABLE" });
+    }
+  }
   return newFields;
 }
 function s3dbTypeToSQLite(fieldType, fieldOptions = {}) {
@@ -13588,6 +13612,8 @@ class BigqueryReplicator extends BaseReplicator {
     this.credentials = config.credentials;
     this.location = config.location || "US";
     this.logTable = config.logTable;
+    this.mutability = config.mutability || "append-only";
+    this._validateMutability(this.mutability);
     this.schemaSync = {
       enabled: config.schemaSync?.enabled || false,
       strategy: config.schemaSync?.strategy || "alter",
@@ -13596,6 +13622,13 @@ class BigqueryReplicator extends BaseReplicator {
       autoCreateColumns: config.schemaSync?.autoCreateColumns !== false
     };
     this.resources = this.parseResourcesConfig(resources);
+    this.versionCounters = /* @__PURE__ */ new Map();
+  }
+  _validateMutability(mutability) {
+    const validModes = ["append-only", "mutable", "immutable"];
+    if (!validModes.includes(mutability)) {
+      throw new Error(`Invalid mutability mode: ${mutability}. Must be one of: ${validModes.join(", ")}`);
+    }
   }
   parseResourcesConfig(resources) {
     const parsed = {};
@@ -13604,24 +13637,31 @@ class BigqueryReplicator extends BaseReplicator {
         parsed[resourceName] = [{
           table: config,
           actions: ["insert"],
-          transform: null
+          transform: null,
+          mutability: this.mutability
         }];
       } else if (Array.isArray(config)) {
         parsed[resourceName] = config.map((item) => {
           if (typeof item === "string") {
-            return { table: item, actions: ["insert"], transform: null };
+            return { table: item, actions: ["insert"], transform: null, mutability: this.mutability };
           }
+          const itemMutability = item.mutability || this.mutability;
+          this._validateMutability(itemMutability);
           return {
             table: item.table,
             actions: item.actions || ["insert"],
-            transform: item.transform || null
+            transform: item.transform || null,
+            mutability: itemMutability
           };
         });
       } else if (typeof config === "object") {
+        const configMutability = config.mutability || this.mutability;
+        this._validateMutability(configMutability);
         parsed[resourceName] = [{
           table: config.table,
           actions: config.actions || ["insert"],
-          transform: config.transform || null
+          transform: config.transform || null,
+          mutability: configMutability
         }];
       }
     }
@@ -13700,8 +13740,9 @@ class BigqueryReplicator extends BaseReplicator {
       );
       for (const tableConfig of tableConfigs) {
         const tableName = tableConfig.table;
+        const mutability = tableConfig.mutability;
         const [okSync, errSync] = await tryFn(async () => {
-          await this.syncTableSchema(tableName, attributes);
+          await this.syncTableSchema(tableName, attributes, mutability);
         });
         if (!okSync) {
           const message = `Schema sync failed for table ${tableName}: ${errSync.message}`;
@@ -13721,7 +13762,7 @@ class BigqueryReplicator extends BaseReplicator {
   /**
    * Sync a single table schema in BigQuery
    */
-  async syncTableSchema(tableName, attributes) {
+  async syncTableSchema(tableName, attributes, mutability = "append-only") {
     const dataset = this.bigqueryClient.dataset(this.datasetId);
     const table = dataset.table(tableName);
     const [exists] = await table.exists();
@@ -13732,15 +13773,16 @@ class BigqueryReplicator extends BaseReplicator {
       if (this.schemaSync.strategy === "validate-only") {
         throw new Error(`Table ${tableName} does not exist (validate-only mode)`);
       }
-      const schema = generateBigQuerySchema(attributes);
+      const schema = generateBigQuerySchema(attributes, mutability);
       if (this.config.verbose) {
-        console.log(`[BigQueryReplicator] Creating table ${tableName} with schema:`, schema);
+        console.log(`[BigQueryReplicator] Creating table ${tableName} with schema (mutability: ${mutability}):`, schema);
       }
       await dataset.createTable(tableName, { schema });
       this.emit("table_created", {
         replicator: this.name,
         tableName,
-        attributes: Object.keys(attributes)
+        attributes: Object.keys(attributes),
+        mutability
       });
       return;
     }
@@ -13749,18 +13791,19 @@ class BigqueryReplicator extends BaseReplicator {
         console.warn(`[BigQueryReplicator] Dropping and recreating table ${tableName}`);
       }
       await table.delete();
-      const schema = generateBigQuerySchema(attributes);
+      const schema = generateBigQuerySchema(attributes, mutability);
       await dataset.createTable(tableName, { schema });
       this.emit("table_recreated", {
         replicator: this.name,
         tableName,
-        attributes: Object.keys(attributes)
+        attributes: Object.keys(attributes),
+        mutability
       });
       return;
     }
     if (this.schemaSync.strategy === "alter" && this.schemaSync.autoCreateColumns) {
       const existingSchema = await getBigQueryTableSchema(this.bigqueryClient, this.datasetId, tableName);
-      const newFields = generateBigQuerySchemaUpdate(attributes, existingSchema);
+      const newFields = generateBigQuerySchemaUpdate(attributes, existingSchema, mutability);
       if (newFields.length > 0) {
         if (this.config.verbose) {
           console.log(`[BigQueryReplicator] Adding ${newFields.length} field(s) to table ${tableName}:`, newFields);
@@ -13778,7 +13821,7 @@ class BigqueryReplicator extends BaseReplicator {
     }
     if (this.schemaSync.strategy === "validate-only") {
       const existingSchema = await getBigQueryTableSchema(this.bigqueryClient, this.datasetId, tableName);
-      const newFields = generateBigQuerySchemaUpdate(attributes, existingSchema);
+      const newFields = generateBigQuerySchemaUpdate(attributes, existingSchema, mutability);
       if (newFields.length > 0) {
         throw new Error(`Table ${tableName} schema mismatch. Missing columns: ${newFields.length}`);
       }
@@ -13797,7 +13840,8 @@ class BigqueryReplicator extends BaseReplicator {
     if (!this.resources[resourceName]) return [];
     return this.resources[resourceName].filter((tableConfig) => tableConfig.actions.includes(operation)).map((tableConfig) => ({
       table: tableConfig.table,
-      transform: tableConfig.transform
+      transform: tableConfig.transform,
+      mutability: tableConfig.mutability
     }));
   }
   applyTransform(data, transformFn) {
@@ -13816,6 +13860,32 @@ class BigqueryReplicator extends BaseReplicator {
     });
     return cleanData;
   }
+  /**
+   * Add tracking fields for append-only and immutable modes
+   * @private
+   */
+  _addTrackingFields(data, operation, mutability, id) {
+    const tracked = { ...data };
+    if (mutability === "append-only" || mutability === "immutable") {
+      tracked._operation_type = operation;
+      tracked._operation_timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    if (mutability === "immutable") {
+      tracked._is_deleted = operation === "delete";
+      tracked._version = this._getNextVersion(id);
+    }
+    return tracked;
+  }
+  /**
+   * Get next version number for immutable mode
+   * @private
+   */
+  _getNextVersion(id) {
+    const current = this.versionCounters.get(id) || 0;
+    const next = current + 1;
+    this.versionCounters.set(id, next);
+    return next;
+  }
   async replicate(resourceName, operation, data, id, beforeData = null) {
     if (!this.enabled || !this.shouldReplicateResource(resourceName)) {
       return { skipped: true, reason: "resource_not_included" };
@@ -13834,9 +13904,14 @@ class BigqueryReplicator extends BaseReplicator {
       for (const tableConfig of tableConfigs) {
         const [okTable, errTable] = await tryFn(async () => {
           const table = dataset.table(tableConfig.table);
+          const mutability = tableConfig.mutability;
           let job;
-          if (operation === "insert") {
-            const transformedData = this.applyTransform(data, tableConfig.transform);
+          const shouldConvertToInsert = (mutability === "append-only" || mutability === "immutable") && (operation === "update" || operation === "delete");
+          if (operation === "insert" || shouldConvertToInsert) {
+            let transformedData = this.applyTransform(data, tableConfig.transform);
+            if (shouldConvertToInsert) {
+              transformedData = this._addTrackingFields(transformedData, operation, mutability, id);
+            }
             try {
               job = await table.insert([transformedData]);
             } catch (error) {
@@ -13848,7 +13923,7 @@ class BigqueryReplicator extends BaseReplicator {
               }
               throw error;
             }
-          } else if (operation === "update") {
+          } else if (operation === "update" && mutability === "mutable") {
             const transformedData = this.applyTransform(data, tableConfig.transform);
             const keys = Object.keys(transformedData).filter((k) => k !== "id");
             const setClause = keys.map((k) => `${k} = @${k}`).join(", ");
@@ -13890,7 +13965,7 @@ class BigqueryReplicator extends BaseReplicator {
               }
             }
             if (!job) throw lastError;
-          } else if (operation === "delete") {
+          } else if (operation === "delete" && mutability === "mutable") {
             const query = `DELETE FROM \`${this.projectId}.${this.datasetId}.${tableConfig.table}\` WHERE id = @id`;
             try {
               const [deleteJob] = await this.bigqueryClient.createQueryJob({
@@ -14026,7 +14101,8 @@ class BigqueryReplicator extends BaseReplicator {
       datasetId: this.datasetId,
       resources: this.resources,
       logTable: this.logTable,
-      schemaSync: this.schemaSync
+      schemaSync: this.schemaSync,
+      mutability: this.mutability
     };
   }
 }
@@ -15747,11 +15823,11 @@ class ConnectionString {
   }
 }
 
-class Client extends EventEmitter {
+class S3Client extends EventEmitter {
   constructor({
     verbose = false,
     id = null,
-    AwsS3Client,
+    AwsS3Client: AwsS3Client2,
     connectionString,
     parallelism = 10,
     httpClientOptions = {}
@@ -15774,7 +15850,7 @@ class Client extends EventEmitter {
       // 60 second timeout
       ...httpClientOptions
     };
-    this.client = AwsS3Client || this.createClient();
+    this.client = AwsS3Client2 || this.createClient();
   }
   createClient() {
     const httpAgent = new http.Agent(this.httpClientOptions);
@@ -21332,7 +21408,7 @@ class Database extends EventEmitter {
     this.id = idGenerator(7);
     this.version = "1";
     this.s3dbVersion = (() => {
-      const [ok, err, version] = tryFn(() => true ? "12.3.0" : "latest");
+      const [ok, err, version] = tryFn(() => true ? "12.4.0" : "latest");
       return ok ? version : "latest";
     })();
     this._resourcesMap = {};
@@ -21388,7 +21464,7 @@ class Database extends EventEmitter {
         connectionString = `s3://${encodeURIComponent(accessKeyId)}:${encodeURIComponent(secretAccessKey)}@${bucket || "s3db"}?${params.toString()}`;
       }
     }
-    this.client = options.client || new Client({
+    this.client = options.client || new S3Client({
       verbose: this.verbose,
       parallelism: this.parallelism,
       connectionString
@@ -26294,7 +26370,7 @@ class S3TfStateDriver extends TfStateDriver {
    */
   async initialize() {
     const { bucket, credentials, region } = this.connectionConfig;
-    this.client = new Client({
+    this.client = new S3Client({
       bucketName: bucket,
       credentials,
       region
@@ -37920,6 +37996,1070 @@ class VectorPlugin extends Plugin {
   }
 }
 
+class MemoryStorage {
+  constructor(config = {}) {
+    this.objects = /* @__PURE__ */ new Map();
+    this.bucket = config.bucket || "s3db";
+    this.enforceLimits = config.enforceLimits || false;
+    this.metadataLimit = config.metadataLimit || 2048;
+    this.maxObjectSize = config.maxObjectSize || 5 * 1024 * 1024 * 1024;
+    this.persistPath = config.persistPath;
+    this.autoPersist = config.autoPersist || false;
+    this.verbose = config.verbose || false;
+  }
+  /**
+   * Generate ETag (MD5 hash) for object body
+   */
+  _generateETag(body) {
+    const buffer = Buffer.isBuffer(body) ? body : Buffer.from(body || "");
+    return crypto$1.createHash("md5").update(buffer).digest("hex");
+  }
+  /**
+   * Calculate metadata size in bytes
+   */
+  _calculateMetadataSize(metadata) {
+    if (!metadata) return 0;
+    let size = 0;
+    for (const [key, value] of Object.entries(metadata)) {
+      size += Buffer.byteLength(key, "utf8");
+      size += Buffer.byteLength(String(value), "utf8");
+    }
+    return size;
+  }
+  /**
+   * Validate limits if enforceLimits is enabled
+   */
+  _validateLimits(body, metadata) {
+    if (!this.enforceLimits) return;
+    const metadataSize = this._calculateMetadataSize(metadata);
+    if (metadataSize > this.metadataLimit) {
+      throw new Error(
+        `Metadata size (${metadataSize} bytes) exceeds limit of ${this.metadataLimit} bytes`
+      );
+    }
+    const bodySize = Buffer.isBuffer(body) ? body.length : Buffer.byteLength(body || "", "utf8");
+    if (bodySize > this.maxObjectSize) {
+      throw new Error(
+        `Object size (${bodySize} bytes) exceeds limit of ${this.maxObjectSize} bytes`
+      );
+    }
+  }
+  /**
+   * Store an object
+   */
+  async put(key, { body, metadata, contentType, contentEncoding, contentLength, ifMatch }) {
+    this._validateLimits(body, metadata);
+    if (ifMatch !== void 0) {
+      const existing = this.objects.get(key);
+      if (existing && existing.etag !== ifMatch) {
+        throw new Error(`Precondition failed: ETag mismatch for key "${key}"`);
+      }
+    }
+    const buffer = Buffer.isBuffer(body) ? body : Buffer.from(body || "");
+    const etag = this._generateETag(buffer);
+    const lastModified = (/* @__PURE__ */ new Date()).toISOString();
+    const size = buffer.length;
+    const objectData = {
+      body: buffer,
+      metadata: metadata || {},
+      contentType: contentType || "application/octet-stream",
+      etag,
+      lastModified,
+      size,
+      contentEncoding,
+      contentLength: contentLength || size
+    };
+    this.objects.set(key, objectData);
+    if (this.verbose) {
+      console.log(`[MemoryStorage] PUT ${key} (${size} bytes, etag: ${etag})`);
+    }
+    if (this.autoPersist && this.persistPath) {
+      await this.saveToDisk();
+    }
+    return {
+      ETag: etag,
+      VersionId: null,
+      // Memory storage doesn't support versioning
+      ServerSideEncryption: null,
+      Location: `/${this.bucket}/${key}`
+    };
+  }
+  /**
+   * Retrieve an object
+   */
+  async get(key) {
+    const obj = this.objects.get(key);
+    if (!obj) {
+      const error = new Error(`Object not found: ${key}`);
+      error.name = "NoSuchKey";
+      error.$metadata = {
+        httpStatusCode: 404,
+        requestId: "memory-" + Date.now(),
+        attempts: 1,
+        totalRetryDelay: 0
+      };
+      throw error;
+    }
+    if (this.verbose) {
+      console.log(`[MemoryStorage] GET ${key} (${obj.size} bytes)`);
+    }
+    const bodyStream = stream$1.Readable.from(obj.body);
+    return {
+      Body: bodyStream,
+      Metadata: { ...obj.metadata },
+      ContentType: obj.contentType,
+      ContentLength: obj.size,
+      ETag: obj.etag,
+      LastModified: new Date(obj.lastModified),
+      ContentEncoding: obj.contentEncoding
+    };
+  }
+  /**
+   * Get object metadata only (like S3 HeadObject)
+   */
+  async head(key) {
+    const obj = this.objects.get(key);
+    if (!obj) {
+      const error = new Error(`Object not found: ${key}`);
+      error.name = "NoSuchKey";
+      error.$metadata = {
+        httpStatusCode: 404,
+        requestId: "memory-" + Date.now(),
+        attempts: 1,
+        totalRetryDelay: 0
+      };
+      throw error;
+    }
+    if (this.verbose) {
+      console.log(`[MemoryStorage] HEAD ${key}`);
+    }
+    return {
+      Metadata: { ...obj.metadata },
+      ContentType: obj.contentType,
+      ContentLength: obj.size,
+      ETag: obj.etag,
+      LastModified: new Date(obj.lastModified),
+      ContentEncoding: obj.contentEncoding
+    };
+  }
+  /**
+   * Copy an object
+   */
+  async copy(from, to, { metadata, metadataDirective, contentType }) {
+    const source = this.objects.get(from);
+    if (!source) {
+      const error = new Error(`Source object not found: ${from}`);
+      error.name = "NoSuchKey";
+      throw error;
+    }
+    let finalMetadata = { ...source.metadata };
+    if (metadataDirective === "REPLACE" && metadata) {
+      finalMetadata = metadata;
+    } else if (metadata) {
+      finalMetadata = { ...finalMetadata, ...metadata };
+    }
+    const result = await this.put(to, {
+      body: source.body,
+      metadata: finalMetadata,
+      contentType: contentType || source.contentType,
+      contentEncoding: source.contentEncoding
+    });
+    if (this.verbose) {
+      console.log(`[MemoryStorage] COPY ${from} \u2192 ${to}`);
+    }
+    return result;
+  }
+  /**
+   * Check if object exists
+   */
+  exists(key) {
+    return this.objects.has(key);
+  }
+  /**
+   * Delete an object
+   */
+  async delete(key) {
+    const existed = this.objects.has(key);
+    this.objects.delete(key);
+    if (this.verbose) {
+      console.log(`[MemoryStorage] DELETE ${key} (existed: ${existed})`);
+    }
+    if (this.autoPersist && this.persistPath) {
+      await this.saveToDisk();
+    }
+    return {
+      DeleteMarker: false,
+      VersionId: null
+    };
+  }
+  /**
+   * Delete multiple objects (batch)
+   */
+  async deleteMultiple(keys) {
+    const deleted = [];
+    const errors = [];
+    for (const key of keys) {
+      try {
+        await this.delete(key);
+        deleted.push({ Key: key });
+      } catch (error) {
+        errors.push({
+          Key: key,
+          Code: error.name || "InternalError",
+          Message: error.message
+        });
+      }
+    }
+    if (this.verbose) {
+      console.log(`[MemoryStorage] DELETE BATCH (${deleted.length} deleted, ${errors.length} errors)`);
+    }
+    return { Deleted: deleted, Errors: errors };
+  }
+  /**
+   * List objects with prefix/delimiter support
+   */
+  async list({ prefix = "", delimiter = null, maxKeys = 1e3, continuationToken = null }) {
+    const allKeys = Array.from(this.objects.keys());
+    let filteredKeys = prefix ? allKeys.filter((key) => key.startsWith(prefix)) : allKeys;
+    filteredKeys.sort();
+    let startIndex = 0;
+    if (continuationToken) {
+      startIndex = parseInt(continuationToken) || 0;
+    }
+    const paginatedKeys = filteredKeys.slice(startIndex, startIndex + maxKeys);
+    const isTruncated = startIndex + maxKeys < filteredKeys.length;
+    const nextContinuationToken = isTruncated ? String(startIndex + maxKeys) : null;
+    const commonPrefixes = /* @__PURE__ */ new Set();
+    const contents = [];
+    for (const key of paginatedKeys) {
+      if (delimiter && prefix) {
+        const suffix = key.substring(prefix.length);
+        const delimiterIndex = suffix.indexOf(delimiter);
+        if (delimiterIndex !== -1) {
+          const commonPrefix = prefix + suffix.substring(0, delimiterIndex + 1);
+          commonPrefixes.add(commonPrefix);
+          continue;
+        }
+      }
+      const obj = this.objects.get(key);
+      contents.push({
+        Key: key,
+        Size: obj.size,
+        LastModified: new Date(obj.lastModified),
+        ETag: obj.etag,
+        StorageClass: "STANDARD"
+      });
+    }
+    if (this.verbose) {
+      console.log(`[MemoryStorage] LIST prefix="${prefix}" (${contents.length} objects, ${commonPrefixes.size} prefixes)`);
+    }
+    return {
+      Contents: contents,
+      CommonPrefixes: Array.from(commonPrefixes).map((prefix2) => ({ Prefix: prefix2 })),
+      IsTruncated: isTruncated,
+      NextContinuationToken: nextContinuationToken,
+      KeyCount: contents.length + commonPrefixes.size,
+      MaxKeys: maxKeys,
+      Prefix: prefix,
+      Delimiter: delimiter
+    };
+  }
+  /**
+   * Create a snapshot of current state
+   */
+  snapshot() {
+    const snapshot = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      bucket: this.bucket,
+      objectCount: this.objects.size,
+      objects: {}
+    };
+    for (const [key, obj] of this.objects.entries()) {
+      snapshot.objects[key] = {
+        body: obj.body.toString("base64"),
+        metadata: obj.metadata,
+        contentType: obj.contentType,
+        etag: obj.etag,
+        lastModified: obj.lastModified,
+        size: obj.size,
+        contentEncoding: obj.contentEncoding,
+        contentLength: obj.contentLength
+      };
+    }
+    return snapshot;
+  }
+  /**
+   * Restore from a snapshot
+   */
+  restore(snapshot) {
+    if (!snapshot || !snapshot.objects) {
+      throw new Error("Invalid snapshot format");
+    }
+    this.objects.clear();
+    for (const [key, obj] of Object.entries(snapshot.objects)) {
+      this.objects.set(key, {
+        body: Buffer.from(obj.body, "base64"),
+        metadata: obj.metadata,
+        contentType: obj.contentType,
+        etag: obj.etag,
+        lastModified: obj.lastModified,
+        size: obj.size,
+        contentEncoding: obj.contentEncoding,
+        contentLength: obj.contentLength
+      });
+    }
+    if (this.verbose) {
+      console.log(`[MemoryStorage] Restored snapshot with ${this.objects.size} objects`);
+    }
+  }
+  /**
+   * Save current state to disk
+   */
+  async saveToDisk(customPath) {
+    const path = customPath || this.persistPath;
+    if (!path) {
+      throw new Error("No persist path configured");
+    }
+    const snapshot = this.snapshot();
+    const json = JSON.stringify(snapshot, null, 2);
+    const [ok, err] = await tryFn(() => promises.writeFile(path, json, "utf-8"));
+    if (!ok) {
+      throw new Error(`Failed to save to disk: ${err.message}`);
+    }
+    if (this.verbose) {
+      console.log(`[MemoryStorage] Saved ${this.objects.size} objects to ${path}`);
+    }
+    return path;
+  }
+  /**
+   * Load state from disk
+   */
+  async loadFromDisk(customPath) {
+    const path = customPath || this.persistPath;
+    if (!path) {
+      throw new Error("No persist path configured");
+    }
+    const [ok, err, json] = await tryFn(() => promises.readFile(path, "utf-8"));
+    if (!ok) {
+      throw new Error(`Failed to load from disk: ${err.message}`);
+    }
+    const snapshot = JSON.parse(json);
+    this.restore(snapshot);
+    if (this.verbose) {
+      console.log(`[MemoryStorage] Loaded ${this.objects.size} objects from ${path}`);
+    }
+    return snapshot;
+  }
+  /**
+   * Get storage statistics
+   */
+  getStats() {
+    let totalSize = 0;
+    const keys = [];
+    for (const [key, obj] of this.objects.entries()) {
+      totalSize += obj.size;
+      keys.push(key);
+    }
+    return {
+      objectCount: this.objects.size,
+      totalSize,
+      totalSizeFormatted: this._formatBytes(totalSize),
+      keys: keys.sort(),
+      bucket: this.bucket
+    };
+  }
+  /**
+   * Format bytes for human reading
+   */
+  _formatBytes(bytes) {
+    if (bytes === 0) return "0 Bytes";
+    const k = 1024;
+    const sizes = ["Bytes", "KB", "MB", "GB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return Math.round(bytes / Math.pow(k, i) * 100) / 100 + " " + sizes[i];
+  }
+  /**
+   * Clear all objects
+   */
+  clear() {
+    this.objects.clear();
+    if (this.verbose) {
+      console.log(`[MemoryStorage] Cleared all objects`);
+    }
+  }
+}
+
+class MemoryClient extends EventEmitter {
+  constructor(config = {}) {
+    super();
+    this.id = config.id || idGenerator(77);
+    this.verbose = config.verbose || false;
+    this.parallelism = config.parallelism || 10;
+    this.bucket = config.bucket || "s3db";
+    this.keyPrefix = config.keyPrefix || "";
+    this.region = config.region || "us-east-1";
+    this.storage = new MemoryStorage({
+      bucket: this.bucket,
+      enforceLimits: config.enforceLimits || false,
+      metadataLimit: config.metadataLimit || 2048,
+      maxObjectSize: config.maxObjectSize || 5 * 1024 * 1024 * 1024,
+      persistPath: config.persistPath,
+      autoPersist: config.autoPersist || false,
+      verbose: this.verbose
+    });
+    this.config = {
+      bucket: this.bucket,
+      keyPrefix: this.keyPrefix,
+      region: this.region,
+      endpoint: "memory://localhost",
+      forcePathStyle: true
+    };
+    if (this.verbose) {
+      console.log(`[MemoryClient] Initialized (id: ${this.id}, bucket: ${this.bucket})`);
+    }
+  }
+  /**
+   * Simulate sendCommand from AWS SDK
+   * Used by Database/Resource to send AWS SDK commands
+   */
+  async sendCommand(command) {
+    const commandName = command.constructor.name;
+    const input = command.input || {};
+    this.emit("command.request", commandName, input);
+    let response;
+    try {
+      switch (commandName) {
+        case "PutObjectCommand":
+          response = await this._handlePutObject(input);
+          break;
+        case "GetObjectCommand":
+          response = await this._handleGetObject(input);
+          break;
+        case "HeadObjectCommand":
+          response = await this._handleHeadObject(input);
+          break;
+        case "CopyObjectCommand":
+          response = await this._handleCopyObject(input);
+          break;
+        case "DeleteObjectCommand":
+          response = await this._handleDeleteObject(input);
+          break;
+        case "DeleteObjectsCommand":
+          response = await this._handleDeleteObjects(input);
+          break;
+        case "ListObjectsV2Command":
+          response = await this._handleListObjects(input);
+          break;
+        default:
+          throw new Error(`Unsupported command: ${commandName}`);
+      }
+      this.emit("command.response", commandName, response, input);
+      return response;
+    } catch (error) {
+      const mappedError = mapAwsError(error, {
+        bucket: this.bucket,
+        key: input.Key,
+        commandName,
+        commandInput: input
+      });
+      throw mappedError;
+    }
+  }
+  /**
+   * PutObjectCommand handler
+   */
+  async _handlePutObject(input) {
+    const key = input.Key;
+    const metadata = input.Metadata || {};
+    const contentType = input.ContentType;
+    const body = input.Body;
+    const contentEncoding = input.ContentEncoding;
+    const contentLength = input.ContentLength;
+    const ifMatch = input.IfMatch;
+    return await this.storage.put(key, {
+      body,
+      metadata,
+      contentType,
+      contentEncoding,
+      contentLength,
+      ifMatch
+    });
+  }
+  /**
+   * GetObjectCommand handler
+   */
+  async _handleGetObject(input) {
+    const key = input.Key;
+    return await this.storage.get(key);
+  }
+  /**
+   * HeadObjectCommand handler
+   */
+  async _handleHeadObject(input) {
+    const key = input.Key;
+    return await this.storage.head(key);
+  }
+  /**
+   * CopyObjectCommand handler
+   */
+  async _handleCopyObject(input) {
+    const copySource = input.CopySource;
+    const parts = copySource.split("/");
+    const sourceKey = parts.slice(1).join("/");
+    const destinationKey = input.Key;
+    const metadata = input.Metadata;
+    const metadataDirective = input.MetadataDirective;
+    const contentType = input.ContentType;
+    return await this.storage.copy(sourceKey, destinationKey, {
+      metadata,
+      metadataDirective,
+      contentType
+    });
+  }
+  /**
+   * DeleteObjectCommand handler
+   */
+  async _handleDeleteObject(input) {
+    const key = input.Key;
+    return await this.storage.delete(key);
+  }
+  /**
+   * DeleteObjectsCommand handler
+   */
+  async _handleDeleteObjects(input) {
+    const objects = input.Delete?.Objects || [];
+    const keys = objects.map((obj) => obj.Key);
+    return await this.storage.deleteMultiple(keys);
+  }
+  /**
+   * ListObjectsV2Command handler
+   */
+  async _handleListObjects(input) {
+    const fullPrefix = this.keyPrefix && input.Prefix ? path$1.join(this.keyPrefix, input.Prefix) : this.keyPrefix || input.Prefix || "";
+    return await this.storage.list({
+      prefix: fullPrefix,
+      delimiter: input.Delimiter,
+      maxKeys: input.MaxKeys,
+      continuationToken: input.ContinuationToken
+    });
+  }
+  /**
+   * Put an object (Client interface method)
+   */
+  async putObject({ key, metadata, contentType, body, contentEncoding, contentLength, ifMatch }) {
+    const fullKey = this.keyPrefix ? path$1.join(this.keyPrefix, key) : key;
+    const stringMetadata = {};
+    if (metadata) {
+      for (const [k, v] of Object.entries(metadata)) {
+        const validKey = String(k).replace(/[^a-zA-Z0-9\-_]/g, "_");
+        const { encoded } = metadataEncode(v);
+        stringMetadata[validKey] = encoded;
+      }
+    }
+    const response = await this.storage.put(fullKey, {
+      body,
+      metadata: stringMetadata,
+      contentType,
+      contentEncoding,
+      contentLength,
+      ifMatch
+    });
+    this.emit("putObject", null, { key, metadata, contentType, body, contentEncoding, contentLength });
+    return response;
+  }
+  /**
+   * Get an object (Client interface method)
+   */
+  async getObject(key) {
+    const fullKey = this.keyPrefix ? path$1.join(this.keyPrefix, key) : key;
+    const response = await this.storage.get(fullKey);
+    const decodedMetadata = {};
+    if (response.Metadata) {
+      for (const [k, v] of Object.entries(response.Metadata)) {
+        decodedMetadata[k] = metadataDecode(v);
+      }
+    }
+    this.emit("getObject", null, { key });
+    return {
+      ...response,
+      Metadata: decodedMetadata
+    };
+  }
+  /**
+   * Head object (get metadata only)
+   */
+  async headObject(key) {
+    const fullKey = this.keyPrefix ? path$1.join(this.keyPrefix, key) : key;
+    const response = await this.storage.head(fullKey);
+    const decodedMetadata = {};
+    if (response.Metadata) {
+      for (const [k, v] of Object.entries(response.Metadata)) {
+        decodedMetadata[k] = metadataDecode(v);
+      }
+    }
+    this.emit("headObject", null, { key });
+    return {
+      ...response,
+      Metadata: decodedMetadata
+    };
+  }
+  /**
+   * Copy an object
+   */
+  async copyObject({ from, to, metadata, metadataDirective, contentType }) {
+    const fullFrom = this.keyPrefix ? path$1.join(this.keyPrefix, from) : from;
+    const fullTo = this.keyPrefix ? path$1.join(this.keyPrefix, to) : to;
+    const encodedMetadata = {};
+    if (metadata) {
+      for (const [k, v] of Object.entries(metadata)) {
+        const validKey = String(k).replace(/[^a-zA-Z0-9\-_]/g, "_");
+        const { encoded } = metadataEncode(v);
+        encodedMetadata[validKey] = encoded;
+      }
+    }
+    const response = await this.storage.copy(fullFrom, fullTo, {
+      metadata: encodedMetadata,
+      metadataDirective,
+      contentType
+    });
+    this.emit("copyObject", null, { from, to, metadata, metadataDirective });
+    return response;
+  }
+  /**
+   * Check if object exists
+   */
+  async exists(key) {
+    const fullKey = this.keyPrefix ? path$1.join(this.keyPrefix, key) : key;
+    return this.storage.exists(fullKey);
+  }
+  /**
+   * Delete an object
+   */
+  async deleteObject(key) {
+    const fullKey = this.keyPrefix ? path$1.join(this.keyPrefix, key) : key;
+    const response = await this.storage.delete(fullKey);
+    this.emit("deleteObject", null, { key });
+    return response;
+  }
+  /**
+   * Delete multiple objects (batch)
+   */
+  async deleteObjects(keys) {
+    const fullKeys = keys.map(
+      (key) => this.keyPrefix ? path$1.join(this.keyPrefix, key) : key
+    );
+    const batches = lodashEs.chunk(fullKeys, this.parallelism);
+    const allResults = { Deleted: [], Errors: [] };
+    const { results } = await promisePool.PromisePool.withConcurrency(this.parallelism).for(batches).process(async (batch) => {
+      return await this.storage.deleteMultiple(batch);
+    });
+    for (const result of results) {
+      allResults.Deleted.push(...result.Deleted);
+      allResults.Errors.push(...result.Errors);
+    }
+    this.emit("deleteObjects", null, { keys, count: allResults.Deleted.length });
+    return allResults;
+  }
+  /**
+   * List objects with pagination support
+   */
+  async listObjects({ prefix = "", delimiter = null, maxKeys = 1e3, continuationToken = null }) {
+    const fullPrefix = this.keyPrefix ? path$1.join(this.keyPrefix, prefix) : prefix;
+    const response = await this.storage.list({
+      prefix: fullPrefix,
+      delimiter,
+      maxKeys,
+      continuationToken
+    });
+    this.emit("listObjects", null, { prefix, count: response.Contents.length });
+    return response;
+  }
+  /**
+   * Get a page of keys with offset/limit pagination
+   */
+  async getKeysPage(params = {}) {
+    const { prefix = "", offset = 0, amount = 100 } = params;
+    let keys = [];
+    let truncated = true;
+    let continuationToken;
+    if (offset > 0) {
+      const fullPrefix = this.keyPrefix ? path$1.join(this.keyPrefix, prefix) : prefix;
+      const response = await this.storage.list({
+        prefix: fullPrefix,
+        maxKeys: offset + amount
+      });
+      keys = response.Contents.map((x) => x.Key).slice(offset, offset + amount);
+    } else {
+      while (truncated) {
+        const options = {
+          prefix,
+          continuationToken,
+          maxKeys: amount - keys.length
+        };
+        const res = await this.listObjects(options);
+        if (res.Contents) {
+          keys = keys.concat(res.Contents.map((x) => x.Key));
+        }
+        truncated = res.IsTruncated || false;
+        continuationToken = res.NextContinuationToken;
+        if (keys.length >= amount) {
+          keys = keys.slice(0, amount);
+          break;
+        }
+      }
+    }
+    if (this.keyPrefix) {
+      keys = keys.map((x) => x.replace(this.keyPrefix, "")).map((x) => x.startsWith("/") ? x.replace("/", "") : x);
+    }
+    this.emit("getKeysPage", keys, params);
+    return keys;
+  }
+  /**
+   * Get all keys with a given prefix
+   */
+  async getAllKeys({ prefix = "" }) {
+    const fullPrefix = this.keyPrefix ? path$1.join(this.keyPrefix, prefix) : prefix;
+    const response = await this.storage.list({
+      prefix: fullPrefix,
+      maxKeys: 1e5
+      // Large number to get all
+    });
+    let keys = response.Contents.map((x) => x.Key);
+    if (this.keyPrefix) {
+      keys = keys.map((x) => x.replace(this.keyPrefix, "")).map((x) => x.startsWith("/") ? x.replace("/", "") : x);
+    }
+    this.emit("getAllKeys", keys, { prefix });
+    return keys;
+  }
+  /**
+   * Count total objects under a prefix
+   */
+  async count({ prefix = "" } = {}) {
+    const keys = await this.getAllKeys({ prefix });
+    const count = keys.length;
+    this.emit("count", count, { prefix });
+    return count;
+  }
+  /**
+   * Delete all objects under a prefix
+   */
+  async deleteAll({ prefix = "" } = {}) {
+    const keys = await this.getAllKeys({ prefix });
+    let totalDeleted = 0;
+    if (keys.length > 0) {
+      const result = await this.deleteObjects(keys);
+      totalDeleted = result.Deleted.length;
+      this.emit("deleteAll", {
+        prefix,
+        batch: totalDeleted,
+        total: totalDeleted
+      });
+    }
+    this.emit("deleteAllComplete", {
+      prefix,
+      totalDeleted
+    });
+    return totalDeleted;
+  }
+  /**
+   * Get continuation token after skipping offset items
+   */
+  async getContinuationTokenAfterOffset({ prefix = "", offset = 1e3 } = {}) {
+    if (offset === 0) return null;
+    const keys = await this.getAllKeys({ prefix });
+    if (offset >= keys.length) {
+      this.emit("getContinuationTokenAfterOffset", null, { prefix, offset });
+      return null;
+    }
+    const token = keys[offset];
+    this.emit("getContinuationTokenAfterOffset", token, { prefix, offset });
+    return token;
+  }
+  /**
+   * Move an object from one key to another
+   */
+  async moveObject({ from, to }) {
+    await this.copyObject({ from, to, metadataDirective: "COPY" });
+    await this.deleteObject(from);
+  }
+  /**
+   * Move all objects from one prefix to another
+   */
+  async moveAllObjects({ prefixFrom, prefixTo }) {
+    const keys = await this.getAllKeys({ prefix: prefixFrom });
+    const results = [];
+    const errors = [];
+    for (const key of keys) {
+      try {
+        const to = key.replace(prefixFrom, prefixTo);
+        await this.moveObject({ from: key, to });
+        results.push(to);
+      } catch (error) {
+        errors.push({
+          message: error.message,
+          raw: error,
+          key
+        });
+      }
+    }
+    this.emit("moveAllObjects", { results, errors }, { prefixFrom, prefixTo });
+    if (errors.length > 0) {
+      const error = new Error("Some objects could not be moved");
+      error.context = {
+        bucket: this.bucket,
+        operation: "moveAllObjects",
+        prefixFrom,
+        prefixTo,
+        totalKeys: keys.length,
+        failedCount: errors.length,
+        successCount: results.length,
+        errors
+      };
+      throw error;
+    }
+    return results;
+  }
+  /**
+   * Create a snapshot of current storage state
+   */
+  snapshot() {
+    return this.storage.snapshot();
+  }
+  /**
+   * Restore from a snapshot
+   */
+  restore(snapshot) {
+    return this.storage.restore(snapshot);
+  }
+  /**
+   * Save current state to disk (persistence)
+   */
+  async saveToDisk(path2) {
+    return await this.storage.saveToDisk(path2);
+  }
+  /**
+   * Load state from disk
+   */
+  async loadFromDisk(path2) {
+    return await this.storage.loadFromDisk(path2);
+  }
+  /**
+   * Export to BackupPlugin-compatible format (s3db.json + JSONL files)
+   * Compatible with BackupPlugin for easy migration
+   *
+   * @param {string} outputDir - Output directory path
+   * @param {Object} options - Export options
+   * @param {Array<string>} options.resources - Resource names to export (default: all)
+   * @param {boolean} options.compress - Use gzip compression (default: true)
+   * @param {Object} options.database - Database instance for schema metadata
+   * @returns {Promise<Object>} Export manifest with file paths and stats
+   */
+  async exportBackup(outputDir, options = {}) {
+    const { mkdir, writeFile } = await import('fs/promises');
+    const zlib = await import('zlib');
+    const { promisify } = await import('util');
+    const gzip = promisify(zlib.gzip);
+    await mkdir(outputDir, { recursive: true });
+    const compress = options.compress !== false;
+    const database = options.database;
+    const resourceFilter = options.resources;
+    const allKeys = await this.getAllKeys({});
+    const resourceMap = /* @__PURE__ */ new Map();
+    for (const key of allKeys) {
+      const match = key.match(/^resource=([^/]+)\//);
+      if (match) {
+        const resourceName = match[1];
+        if (!resourceFilter || resourceFilter.includes(resourceName)) {
+          if (!resourceMap.has(resourceName)) {
+            resourceMap.set(resourceName, []);
+          }
+          resourceMap.get(resourceName).push(key);
+        }
+      }
+    }
+    const exportedFiles = {};
+    const resourceStats = {};
+    for (const [resourceName, keys] of resourceMap.entries()) {
+      const records = [];
+      for (const key of keys) {
+        const obj = await this.getObject(key);
+        const idMatch = key.match(/\/id=([^/]+)/);
+        const recordId = idMatch ? idMatch[1] : null;
+        const record = { ...obj.Metadata };
+        if (recordId && !record.id) {
+          record.id = recordId;
+        }
+        if (obj.Body) {
+          const chunks = [];
+          for await (const chunk2 of obj.Body) {
+            chunks.push(chunk2);
+          }
+          const bodyBuffer = Buffer.concat(chunks);
+          const bodyStr = bodyBuffer.toString("utf-8");
+          if (bodyStr.startsWith("{") || bodyStr.startsWith("[")) {
+            try {
+              const bodyData = JSON.parse(bodyStr);
+              Object.assign(record, bodyData);
+            } catch {
+              record._body = bodyStr;
+            }
+          } else if (bodyStr) {
+            record._body = bodyStr;
+          }
+        }
+        records.push(record);
+      }
+      const jsonl = records.map((r) => JSON.stringify(r)).join("\n");
+      const filename = compress ? `${resourceName}.jsonl.gz` : `${resourceName}.jsonl`;
+      const filePath = `${outputDir}/${filename}`;
+      if (compress) {
+        const compressed = await gzip(jsonl);
+        await writeFile(filePath, compressed);
+      } else {
+        await writeFile(filePath, jsonl, "utf-8");
+      }
+      exportedFiles[resourceName] = filePath;
+      resourceStats[resourceName] = {
+        recordCount: records.length,
+        fileSize: compress ? (await gzip(jsonl)).length : Buffer.byteLength(jsonl)
+      };
+    }
+    const s3dbMetadata = {
+      version: "1.0",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      bucket: this.bucket,
+      keyPrefix: this.keyPrefix || "",
+      compressed: compress,
+      resources: {},
+      totalRecords: 0,
+      totalSize: 0
+    };
+    if (database && database.resources) {
+      for (const [resourceName, resource] of Object.entries(database.resources)) {
+        if (resourceMap.has(resourceName)) {
+          s3dbMetadata.resources[resourceName] = {
+            schema: resource.schema ? {
+              attributes: resource.schema.attributes,
+              partitions: resource.schema.partitions,
+              behavior: resource.schema.behavior,
+              timestamps: resource.schema.timestamps
+            } : null,
+            stats: resourceStats[resourceName]
+          };
+        }
+      }
+    } else {
+      for (const [resourceName, stats] of Object.entries(resourceStats)) {
+        s3dbMetadata.resources[resourceName] = { stats };
+      }
+    }
+    for (const stats of Object.values(resourceStats)) {
+      s3dbMetadata.totalRecords += stats.recordCount;
+      s3dbMetadata.totalSize += stats.fileSize;
+    }
+    const s3dbPath = `${outputDir}/s3db.json`;
+    await writeFile(s3dbPath, JSON.stringify(s3dbMetadata, null, 2), "utf-8");
+    return {
+      manifest: s3dbPath,
+      files: exportedFiles,
+      stats: s3dbMetadata,
+      resourceCount: resourceMap.size,
+      totalRecords: s3dbMetadata.totalRecords,
+      totalSize: s3dbMetadata.totalSize
+    };
+  }
+  /**
+   * Import from BackupPlugin-compatible format
+   * Loads data from s3db.json + JSONL files created by BackupPlugin or exportBackup()
+   *
+   * @param {string} backupDir - Backup directory path containing s3db.json
+   * @param {Object} options - Import options
+   * @param {Array<string>} options.resources - Resource names to import (default: all)
+   * @param {boolean} options.clear - Clear existing data first (default: false)
+   * @param {Object} options.database - Database instance to recreate schemas
+   * @returns {Promise<Object>} Import stats
+   */
+  async importBackup(backupDir, options = {}) {
+    const { readFile, readdir } = await import('fs/promises');
+    const zlib = await import('zlib');
+    const { promisify } = await import('util');
+    const gunzip = promisify(zlib.gunzip);
+    if (options.clear) {
+      this.clear();
+    }
+    const s3dbPath = `${backupDir}/s3db.json`;
+    const s3dbContent = await readFile(s3dbPath, "utf-8");
+    const metadata = JSON.parse(s3dbContent);
+    const database = options.database;
+    const resourceFilter = options.resources;
+    const importStats = {
+      resourcesImported: 0,
+      recordsImported: 0,
+      errors: []
+    };
+    if (database && metadata.resources) {
+      for (const [resourceName, resourceMeta] of Object.entries(metadata.resources)) {
+        if (resourceFilter && !resourceFilter.includes(resourceName)) continue;
+        if (resourceMeta.schema) {
+          try {
+            await database.createResource({
+              name: resourceName,
+              ...resourceMeta.schema
+            });
+          } catch (error) {
+          }
+        }
+      }
+    }
+    const files = await readdir(backupDir);
+    for (const file of files) {
+      if (!file.endsWith(".jsonl") && !file.endsWith(".jsonl.gz")) continue;
+      const resourceName = file.replace(/\.jsonl(\.gz)?$/, "");
+      if (resourceFilter && !resourceFilter.includes(resourceName)) continue;
+      const filePath = `${backupDir}/${file}`;
+      let content = await readFile(filePath);
+      if (file.endsWith(".gz")) {
+        content = await gunzip(content);
+      }
+      const jsonl = content.toString("utf-8");
+      const lines = jsonl.split("\n").filter((line) => line.trim());
+      for (const line of lines) {
+        try {
+          const record = JSON.parse(line);
+          const id = record.id || record._id || `imported_${Date.now()}_${Math.random()}`;
+          const { _body, id: _, _id: __, ...metadata2 } = record;
+          await this.putObject({
+            key: `resource=${resourceName}/id=${id}`,
+            metadata: metadata2,
+            body: _body ? Buffer.from(_body) : void 0
+          });
+          importStats.recordsImported++;
+        } catch (error) {
+          importStats.errors.push({
+            resource: resourceName,
+            error: error.message,
+            line
+          });
+        }
+      }
+      importStats.resourcesImported++;
+    }
+    return importStats;
+  }
+  /**
+   * Get storage statistics
+   */
+  getStats() {
+    return this.storage.getStats();
+  }
+  /**
+   * Clear all objects
+   */
+  clear() {
+    this.storage.clear();
+  }
+}
+
 function mapFieldTypeToTypeScript(fieldType) {
   const baseType = fieldType.split("|")[0].trim();
   const typeMap = {
@@ -38840,7 +39980,7 @@ exports.BigqueryReplicator = BigqueryReplicator;
 exports.CONSUMER_DRIVERS = CONSUMER_DRIVERS;
 exports.Cache = Cache;
 exports.CachePlugin = CachePlugin;
-exports.Client = Client;
+exports.Client = S3Client;
 exports.ConnectionString = ConnectionString;
 exports.ConnectionStringError = ConnectionStringError;
 exports.CostsPlugin = CostsPlugin;
@@ -38859,6 +39999,8 @@ exports.FullTextPlugin = FullTextPlugin;
 exports.GeoPlugin = GeoPlugin;
 exports.InvalidResourceItem = InvalidResourceItem;
 exports.MemoryCache = MemoryCache;
+exports.MemoryClient = MemoryClient;
+exports.MemoryStorage = MemoryStorage;
 exports.MetadataLimitError = MetadataLimitError;
 exports.MetricsPlugin = MetricsPlugin;
 exports.MissingMetadata = MissingMetadata;
@@ -38892,6 +40034,7 @@ exports.ResourceReader = ResourceReader;
 exports.ResourceWriter = ResourceWriter;
 exports.S3BackupDriver = S3BackupDriver;
 exports.S3Cache = S3Cache;
+exports.S3Client = S3Client;
 exports.S3QueuePlugin = S3QueuePlugin;
 exports.S3db = Database;
 exports.S3dbError = S3dbError;