s3db.js 8.0.3 → 8.1.0

package/dist/s3db.d.ts

@@ -34,6 +34,7 @@ declare module 's3db.js' {
     parallelism?: number | string;
     passphrase?: string;
     versioningEnabled?: boolean;
+    persistHooks?: boolean;
     cache?: CacheConfig | boolean;
     plugins?: (PluginInterface | PluginFunction)[];
     client?: Client;

package/dist/s3db.es.js

@@ -13433,7 +13433,7 @@ class Database extends EventEmitter {
     this.id = idGenerator(7);
     this.version = "1";
     this.s3dbVersion = (() => {
-      const [ok, err, version] = try_fn_default(() => true ? "8.0.2" : "latest");
+      const [ok, err, version] = try_fn_default(() => true ? "8.1.0" : "latest");
       return ok ? version : "latest";
     })();
     this.resources = {};
@@ -13446,6 +13446,7 @@ class Database extends EventEmitter {
     this.cache = options.cache;
     this.passphrase = options.passphrase || "secret";
     this.versioningEnabled = options.versioningEnabled || false;
+    this.persistHooks = options.persistHooks || false;
     this._initHooks();
     let connectionString = options.connectionString;
     if (!connectionString && (options.bucket || options.accessKeyId || options.secretAccessKey)) {
@@ -13492,13 +13493,42 @@ class Database extends EventEmitter {
   async connect() {
     await this.startPlugins();
     let metadata = null;
+    let needsHealing = false;
+    let healingLog = [];
     if (await this.client.exists(`s3db.json`)) {
-      const request = await this.client.getObject(`s3db.json`);
-      metadata = JSON.parse(await streamToString(request?.Body));
+      try {
+        const request = await this.client.getObject(`s3db.json`);
+        const rawContent = await streamToString(request?.Body);
+        try {
+          metadata = JSON.parse(rawContent);
+        } catch (parseError) {
+          healingLog.push("JSON parsing failed - attempting recovery");
+          needsHealing = true;
+          metadata = await this._attemptJsonRecovery(rawContent, healingLog);
+          if (!metadata) {
+            await this._createCorruptedBackup(rawContent);
+            healingLog.push("Created backup of corrupted file - starting with blank metadata");
+            metadata = this.blankMetadataStructure();
+          }
+        }
+        const healedMetadata = await this._validateAndHealMetadata(metadata, healingLog);
+        if (healedMetadata !== metadata) {
+          metadata = healedMetadata;
+          needsHealing = true;
+        }
+      } catch (error) {
+        healingLog.push(`Critical error reading s3db.json: ${error.message}`);
+        await this._createCorruptedBackup();
+        metadata = this.blankMetadataStructure();
+        needsHealing = true;
+      }
     } else {
       metadata = this.blankMetadataStructure();
       await this.uploadMetadataFile();
     }
+    if (needsHealing) {
+      await this._uploadHealedMetadata(metadata, healingLog);
+    }
     this.savedMetadata = metadata;
     const definitionChanges = this.detectDefinitionChanges(metadata);
     for (const [name, resourceMetadata] of Object.entries(metadata.resources || {})) {
@@ -13534,7 +13564,7 @@ class Database extends EventEmitter {
           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 || {},
+          hooks: this.persistHooks ? this._deserializeHooks(versionData.hooks || {}) : versionData.hooks || {},
           versioningEnabled: this.versioningEnabled,
           map: versionData.map,
           idGenerator: restoredIdGenerator,
@@ -13629,6 +13659,73 @@ class Database extends EventEmitter {
     const maxVersion = versionNumbers.length > 0 ? Math.max(...versionNumbers) : -1;
     return `v${maxVersion + 1}`;
   }
+  /**
+   * Serialize hooks to strings for JSON persistence
+   * @param {Object} hooks - Hooks object with event names as keys and function arrays as values
+   * @returns {Object} Serialized hooks object
+   * @private
+   */
+  _serializeHooks(hooks) {
+    if (!hooks || typeof hooks !== "object") return hooks;
+    const serialized = {};
+    for (const [event, hookArray] of Object.entries(hooks)) {
+      if (Array.isArray(hookArray)) {
+        serialized[event] = hookArray.map((hook) => {
+          if (typeof hook === "function") {
+            try {
+              return {
+                __s3db_serialized_function: true,
+                code: hook.toString(),
+                name: hook.name || "anonymous"
+              };
+            } catch (err) {
+              if (this.verbose) {
+                console.warn(`Failed to serialize hook for event '${event}':`, err.message);
+              }
+              return null;
+            }
+          }
+          return hook;
+        });
+      } else {
+        serialized[event] = hookArray;
+      }
+    }
+    return serialized;
+  }
+  /**
+   * Deserialize hooks from strings back to functions
+   * @param {Object} serializedHooks - Serialized hooks object
+   * @returns {Object} Deserialized hooks object
+   * @private
+   */
+  _deserializeHooks(serializedHooks) {
+    if (!serializedHooks || typeof serializedHooks !== "object") return serializedHooks;
+    const deserialized = {};
+    for (const [event, hookArray] of Object.entries(serializedHooks)) {
+      if (Array.isArray(hookArray)) {
+        deserialized[event] = hookArray.map((hook) => {
+          if (hook && typeof hook === "object" && hook.__s3db_serialized_function) {
+            try {
+              const fn = new Function("return " + hook.code)();
+              if (typeof fn === "function") {
+                return fn;
+              }
+            } catch (err) {
+              if (this.verbose) {
+                console.warn(`Failed to deserialize hook '${hook.name}' for event '${event}':`, err.message);
+              }
+            }
+            return null;
+          }
+          return hook;
+        }).filter((hook) => hook !== null);
+      } else {
+        deserialized[event] = hookArray;
+      }
+    }
+    return deserialized;
+  }
   async startPlugins() {
     const db = this;
     if (!isEmpty(this.pluginList)) {
@@ -13698,7 +13795,7 @@ class Database extends EventEmitter {
             allNestedObjectsOptional: resource.config.allNestedObjectsOptional,
             autoDecrypt: resource.config.autoDecrypt,
             cache: resource.config.cache,
-            hooks: resource.config.hooks,
+            hooks: this.persistHooks ? this._serializeHooks(resource.config.hooks) : resource.config.hooks,
             idSize: resource.idSize,
             idGenerator: resource.idGeneratorType,
             createdAt: isNewVersion ? (/* @__PURE__ */ new Date()).toISOString() : existingVersionData?.createdAt
@@ -13722,9 +13819,269 @@ class Database extends EventEmitter {
     return {
       version: `1`,
       s3dbVersion: this.s3dbVersion,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
       resources: {}
     };
   }
+  /**
+   * Attempt to recover JSON from corrupted content
+   */
+  async _attemptJsonRecovery(content, healingLog) {
+    if (!content || typeof content !== "string") {
+      healingLog.push("Content is empty or not a string");
+      return null;
+    }
+    const fixes = [
+      // Remove trailing commas
+      () => content.replace(/,(\s*[}\]])/g, "$1"),
+      // Add missing quotes to keys
+      () => content.replace(/([{,]\s*)([a-zA-Z_$][a-zA-Z0-9_$]*)\s*:/g, '$1"$2":'),
+      // Fix incomplete objects by adding closing braces
+      () => {
+        let openBraces = 0;
+        let openBrackets = 0;
+        let inString = false;
+        let escaped = false;
+        for (let i = 0; i < content.length; i++) {
+          const char = content[i];
+          if (escaped) {
+            escaped = false;
+            continue;
+          }
+          if (char === "\\") {
+            escaped = true;
+            continue;
+          }
+          if (char === '"') {
+            inString = !inString;
+            continue;
+          }
+          if (!inString) {
+            if (char === "{") openBraces++;
+            else if (char === "}") openBraces--;
+            else if (char === "[") openBrackets++;
+            else if (char === "]") openBrackets--;
+          }
+        }
+        let fixed = content;
+        while (openBrackets > 0) {
+          fixed += "]";
+          openBrackets--;
+        }
+        while (openBraces > 0) {
+          fixed += "}";
+          openBraces--;
+        }
+        return fixed;
+      }
+    ];
+    for (const [index, fix] of fixes.entries()) {
+      try {
+        const fixedContent = fix();
+        const parsed = JSON.parse(fixedContent);
+        healingLog.push(`JSON recovery successful using fix #${index + 1}`);
+        return parsed;
+      } catch (error) {
+      }
+    }
+    healingLog.push("All JSON recovery attempts failed");
+    return null;
+  }
+  /**
+   * Validate and heal metadata structure
+   */
+  async _validateAndHealMetadata(metadata, healingLog) {
+    if (!metadata || typeof metadata !== "object") {
+      healingLog.push("Metadata is not an object - using blank structure");
+      return this.blankMetadataStructure();
+    }
+    let healed = { ...metadata };
+    let changed = false;
+    if (!healed.version || typeof healed.version !== "string") {
+      if (healed.version && typeof healed.version === "number") {
+        healed.version = String(healed.version);
+        healingLog.push("Converted version from number to string");
+        changed = true;
+      } else {
+        healed.version = "1";
+        healingLog.push("Added missing or invalid version field");
+        changed = true;
+      }
+    }
+    if (!healed.s3dbVersion || typeof healed.s3dbVersion !== "string") {
+      if (healed.s3dbVersion && typeof healed.s3dbVersion !== "string") {
+        healed.s3dbVersion = String(healed.s3dbVersion);
+        healingLog.push("Converted s3dbVersion to string");
+        changed = true;
+      } else {
+        healed.s3dbVersion = this.s3dbVersion;
+        healingLog.push("Added missing s3dbVersion field");
+        changed = true;
+      }
+    }
+    if (!healed.resources || typeof healed.resources !== "object" || Array.isArray(healed.resources)) {
+      healed.resources = {};
+      healingLog.push("Fixed invalid resources field");
+      changed = true;
+    }
+    if (!healed.lastUpdated) {
+      healed.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+      healingLog.push("Added missing lastUpdated field");
+      changed = true;
+    }
+    const validResources = {};
+    for (const [name, resource] of Object.entries(healed.resources)) {
+      const healedResource = this._healResourceStructure(name, resource, healingLog);
+      if (healedResource) {
+        validResources[name] = healedResource;
+        if (healedResource !== resource) {
+          changed = true;
+        }
+      } else {
+        healingLog.push(`Removed invalid resource: ${name}`);
+        changed = true;
+      }
+    }
+    healed.resources = validResources;
+    return changed ? healed : metadata;
+  }
+  /**
+   * Heal individual resource structure
+   */
+  _healResourceStructure(name, resource, healingLog) {
+    if (!resource || typeof resource !== "object") {
+      healingLog.push(`Resource ${name}: invalid structure`);
+      return null;
+    }
+    let healed = { ...resource };
+    let changed = false;
+    if (!healed.currentVersion) {
+      healed.currentVersion = "v0";
+      healingLog.push(`Resource ${name}: added missing currentVersion`);
+      changed = true;
+    }
+    if (!healed.versions || typeof healed.versions !== "object" || Array.isArray(healed.versions)) {
+      healed.versions = {};
+      healingLog.push(`Resource ${name}: fixed invalid versions object`);
+      changed = true;
+    }
+    if (!healed.partitions || typeof healed.partitions !== "object" || Array.isArray(healed.partitions)) {
+      healed.partitions = {};
+      healingLog.push(`Resource ${name}: fixed invalid partitions object`);
+      changed = true;
+    }
+    const currentVersion = healed.currentVersion;
+    if (!healed.versions[currentVersion]) {
+      const availableVersions = Object.keys(healed.versions);
+      if (availableVersions.length > 0) {
+        healed.currentVersion = availableVersions[0];
+        healingLog.push(`Resource ${name}: changed currentVersion from ${currentVersion} to ${healed.currentVersion}`);
+        changed = true;
+      } else {
+        healingLog.push(`Resource ${name}: no valid versions found - removing resource`);
+        return null;
+      }
+    }
+    const versionData = healed.versions[healed.currentVersion];
+    if (!versionData || typeof versionData !== "object") {
+      healingLog.push(`Resource ${name}: invalid version data - removing resource`);
+      return null;
+    }
+    if (!versionData.attributes || typeof versionData.attributes !== "object") {
+      healingLog.push(`Resource ${name}: missing or invalid attributes - removing resource`);
+      return null;
+    }
+    if (versionData.hooks) {
+      const healedHooks = this._healHooksStructure(versionData.hooks, name, healingLog);
+      if (healedHooks !== versionData.hooks) {
+        healed.versions[healed.currentVersion].hooks = healedHooks;
+        changed = true;
+      }
+    }
+    return changed ? healed : resource;
+  }
+  /**
+   * Heal hooks structure
+   */
+  _healHooksStructure(hooks, resourceName, healingLog) {
+    if (!hooks || typeof hooks !== "object") {
+      healingLog.push(`Resource ${resourceName}: invalid hooks structure - using empty hooks`);
+      return {};
+    }
+    const healed = {};
+    let changed = false;
+    for (const [event, hookArray] of Object.entries(hooks)) {
+      if (Array.isArray(hookArray)) {
+        const validHooks = hookArray.filter(
+          (hook) => hook !== null && hook !== void 0 && hook !== ""
+        );
+        healed[event] = validHooks;
+        if (validHooks.length !== hookArray.length) {
+          healingLog.push(`Resource ${resourceName}: cleaned invalid hooks for event ${event}`);
+          changed = true;
+        }
+      } else {
+        healingLog.push(`Resource ${resourceName}: hooks for event ${event} is not an array - removing`);
+        changed = true;
+      }
+    }
+    return changed ? healed : hooks;
+  }
+  /**
+   * Create backup of corrupted file
+   */
+  async _createCorruptedBackup(content = null) {
+    try {
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+      const backupKey = `s3db.json.corrupted.${timestamp}.backup`;
+      if (!content) {
+        try {
+          const request = await this.client.getObject(`s3db.json`);
+          content = await streamToString(request?.Body);
+        } catch (error) {
+          content = "Unable to read corrupted file content";
+        }
+      }
+      await this.client.putObject({
+        key: backupKey,
+        body: content,
+        contentType: "application/json"
+      });
+      if (this.verbose) {
+        console.warn(`S3DB: Created backup of corrupted s3db.json as ${backupKey}`);
+      }
+    } catch (error) {
+      if (this.verbose) {
+        console.warn(`S3DB: Failed to create backup: ${error.message}`);
+      }
+    }
+  }
+  /**
+   * Upload healed metadata with logging
+   */
+  async _uploadHealedMetadata(metadata, healingLog) {
+    try {
+      if (this.verbose && healingLog.length > 0) {
+        console.warn("S3DB Self-Healing Operations:");
+        healingLog.forEach((log) => console.warn(`  - ${log}`));
+      }
+      metadata.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+      await this.client.putObject({
+        key: "s3db.json",
+        body: JSON.stringify(metadata, null, 2),
+        contentType: "application/json"
+      });
+      this.emit("metadataHealed", { healingLog, metadata });
+      if (this.verbose) {
+        console.warn("S3DB: Successfully uploaded healed metadata");
+      }
+    } catch (error) {
+      if (this.verbose) {
+        console.error(`S3DB: Failed to upload healed metadata: ${error.message}`);
+      }
+      throw error;
+    }
+  }
   /**
    * Check if a resource exists by name
    * @param {string} name - Resource name