hazo_files 1.0.1 → 1.1.0

package/dist/index.js

@@ -39,6 +39,7 @@ __export(index_exports, {
   DirectoryNotFoundError: () => DirectoryNotFoundError,
   FileExistsError: () => FileExistsError,
   FileManager: () => FileManager,
+  FileMetadataService: () => FileMetadataService,
   FileNotFoundError: () => FileNotFoundError,
   FileTooLargeError: () => FileTooLargeError,
   GoogleDriveAuth: () => GoogleDriveAuth,
@@ -52,18 +53,22 @@ __export(index_exports, {
   SYSTEM_COUNTER_VARIABLES: () => SYSTEM_COUNTER_VARIABLES,
   SYSTEM_DATE_VARIABLES: () => SYSTEM_DATE_VARIABLES,
   SYSTEM_FILE_VARIABLES: () => SYSTEM_FILE_VARIABLES,
+  TrackedFileManager: () => TrackedFileManager,
   clonePattern: () => clonePattern,
   createAndInitializeModule: () => createAndInitializeModule,
   createEmptyNamingRuleSchema: () => createEmptyNamingRuleSchema,
   createFileItem: () => createFileItem,
   createFileManager: () => createFileManager,
+  createFileMetadataService: () => createFileMetadataService,
   createFolderItem: () => createFolderItem,
   createGoogleDriveAuth: () => createGoogleDriveAuth,
   createGoogleDriveModule: () => createGoogleDriveModule,
   createInitializedFileManager: () => createInitializedFileManager,
+  createInitializedTrackedFileManager: () => createInitializedTrackedFileManager,
   createLiteralSegment: () => createLiteralSegment,
   createLocalModule: () => createLocalModule,
   createModule: () => createModule,
+  createTrackedFileManager: () => createTrackedFileManager,
   createVariableSegment: () => createVariableSegment,
   errorResult: () => errorResult,
   filterItems: () => filterItems,
@@ -141,12 +146,12 @@ function parseConfig(configContent) {
   }
   if (parsed.google_drive) {
     config.google_drive = {
-      clientId: parsed.google_drive.client_id || process.env.GOOGLE_DRIVE_CLIENT_ID || "",
-      clientSecret: parsed.google_drive.client_secret || process.env.GOOGLE_DRIVE_CLIENT_SECRET || "",
-      redirectUri: parsed.google_drive.redirect_uri || process.env.GOOGLE_DRIVE_REDIRECT_URI || "",
-      refreshToken: parsed.google_drive.refresh_token || process.env.GOOGLE_DRIVE_REFRESH_TOKEN,
-      accessToken: parsed.google_drive.access_token || process.env.GOOGLE_DRIVE_ACCESS_TOKEN,
-      rootFolderId: parsed.google_drive.root_folder_id || process.env.GOOGLE_DRIVE_ROOT_FOLDER_ID
+      clientId: parsed.google_drive.client_id || process.env.HAZO_GOOGLE_DRIVE_CLIENT_ID || "",
+      clientSecret: parsed.google_drive.client_secret || process.env.HAZO_GOOGLE_DRIVE_CLIENT_SECRET || "",
+      redirectUri: parsed.google_drive.redirect_uri || process.env.HAZO_GOOGLE_DRIVE_REDIRECT_URI || "",
+      refreshToken: parsed.google_drive.refresh_token || process.env.HAZO_GOOGLE_DRIVE_REFRESH_TOKEN,
+      accessToken: parsed.google_drive.access_token || process.env.HAZO_GOOGLE_DRIVE_ACCESS_TOKEN,
+      rootFolderId: parsed.google_drive.root_folder_id || process.env.HAZO_GOOGLE_DRIVE_ROOT_FOLDER_ID
     };
   }
   return config;
@@ -202,7 +207,7 @@ max_file_size = 0
 [google_drive]
 ; Google Drive OAuth credentials
 ; These can also be set via environment variables:
-; GOOGLE_DRIVE_CLIENT_ID, GOOGLE_DRIVE_CLIENT_SECRET, etc.
+; HAZO_GOOGLE_DRIVE_CLIENT_ID, HAZO_GOOGLE_DRIVE_CLIENT_SECRET, etc.
 client_id =
 client_secret =
 redirect_uri = http://localhost:3000/api/auth/callback/google
@@ -2043,6 +2048,447 @@ async function createInitializedFileManager(options) {
   return manager;
 }
 
+// src/services/file-metadata-service.ts
+var FileMetadataService = class {
+  constructor(crudService, options = {}) {
+    this.crud = crudService;
+    this.logger = options.logger;
+    this.logErrors = options.logErrors !== false;
+  }
+  /**
+   * Generate ISO timestamp
+   */
+  now() {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+  /**
+   * Log an error if logging is enabled
+   */
+  logError(operation, error) {
+    if (this.logErrors) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger?.error?.(`FileMetadataService.${operation} failed`, { error: message });
+      if (!this.logger) {
+        console.error(`[FileMetadataService] ${operation} failed:`, message);
+      }
+    }
+  }
+  /**
+   * Record a file upload
+   */
+  async recordUpload(input) {
+    try {
+      const timestamp = this.now();
+      const record = {
+        filename: input.filename,
+        file_type: input.file_type,
+        file_data: JSON.stringify(input.file_data || {}),
+        file_path: input.file_path,
+        storage_type: input.storage_type,
+        created_at: timestamp,
+        changed_at: timestamp
+      };
+      const results = await this.crud.insert(record);
+      this.logger?.debug?.("Recorded file upload", { path: input.file_path });
+      return results[0] || null;
+    } catch (error) {
+      this.logError("recordUpload", error);
+      return null;
+    }
+  }
+  /**
+   * Record a directory creation
+   */
+  async recordDirectoryCreation(path3, storageType, metadata) {
+    return this.recordUpload({
+      filename: getBaseName(path3),
+      file_type: "folder",
+      file_data: metadata,
+      file_path: path3,
+      storage_type: storageType
+    });
+  }
+  /**
+   * Record a file access (download)
+   */
+  async recordAccess(path3, storageType) {
+    try {
+      const existing = await this.findByPath(path3, storageType);
+      if (existing) {
+        await this.crud.updateById(existing.id, {
+          changed_at: this.now()
+        });
+        this.logger?.debug?.("Recorded file access", { path: path3 });
+        return true;
+      }
+      return false;
+    } catch (error) {
+      this.logError("recordAccess", error);
+      return false;
+    }
+  }
+  /**
+   * Record a file deletion
+   */
+  async recordDelete(path3, storageType) {
+    try {
+      const existing = await this.findByPath(path3, storageType);
+      if (existing) {
+        await this.crud.deleteById(existing.id);
+        this.logger?.debug?.("Recorded file deletion", { path: path3 });
+        return true;
+      }
+      return false;
+    } catch (error) {
+      this.logError("recordDelete", error);
+      return false;
+    }
+  }
+  /**
+   * Record a directory deletion (recursive)
+   */
+  async recordDirectoryDelete(path3, storageType, recursive) {
+    try {
+      if (recursive) {
+        const records = await this.crud.findBy({ storage_type: storageType });
+        const toDelete = records.filter(
+          (r) => r.file_path === path3 || r.file_path.startsWith(path3 + "/")
+        );
+        for (const record of toDelete) {
+          await this.crud.deleteById(record.id);
+        }
+        this.logger?.debug?.("Recorded recursive directory deletion", {
+          path: path3,
+          count: toDelete.length
+        });
+        return true;
+      } else {
+        return this.recordDelete(path3, storageType);
+      }
+    } catch (error) {
+      this.logError("recordDirectoryDelete", error);
+      return false;
+    }
+  }
+  /**
+   * Record a file or folder move
+   */
+  async recordMove(sourcePath, destinationPath, storageType) {
+    try {
+      const existing = await this.findByPath(sourcePath, storageType);
+      if (existing) {
+        await this.crud.updateById(existing.id, {
+          file_path: destinationPath,
+          filename: getBaseName(destinationPath),
+          changed_at: this.now()
+        });
+        this.logger?.debug?.("Recorded file move", { from: sourcePath, to: destinationPath });
+        return true;
+      }
+      return false;
+    } catch (error) {
+      this.logError("recordMove", error);
+      return false;
+    }
+  }
+  /**
+   * Record a file or folder rename
+   */
+  async recordRename(path3, newName, storageType) {
+    try {
+      const existing = await this.findByPath(path3, storageType);
+      if (existing) {
+        const parentPath = getDirName(path3);
+        const newPath = parentPath === "/" ? `/${newName}` : `${parentPath}/${newName}`;
+        await this.crud.updateById(existing.id, {
+          filename: newName,
+          file_path: newPath,
+          changed_at: this.now()
+        });
+        this.logger?.debug?.("Recorded file rename", { path: path3, newName });
+        return true;
+      }
+      return false;
+    } catch (error) {
+      this.logError("recordRename", error);
+      return false;
+    }
+  }
+  /**
+   * Find a record by path and storage type
+   */
+  async findByPath(path3, storageType) {
+    try {
+      return await this.crud.findOneBy({
+        file_path: path3,
+        storage_type: storageType
+      });
+    } catch (error) {
+      this.logError("findByPath", error);
+      return null;
+    }
+  }
+  /**
+   * Find all records for a storage type
+   */
+  async findByStorageType(storageType) {
+    try {
+      return await this.crud.findBy({ storage_type: storageType });
+    } catch (error) {
+      this.logError("findByStorageType", error);
+      return [];
+    }
+  }
+  /**
+   * Find all records in a directory
+   */
+  async findInDirectory(directoryPath, storageType) {
+    try {
+      const all = await this.findByStorageType(storageType);
+      const prefix = directoryPath === "/" ? "/" : directoryPath + "/";
+      return all.filter((r) => {
+        if (directoryPath === "/") {
+          const segments = r.file_path.split("/").filter(Boolean);
+          return segments.length === 1;
+        }
+        if (!r.file_path.startsWith(prefix)) return false;
+        const relativePath = r.file_path.slice(prefix.length);
+        return !relativePath.includes("/");
+      });
+    } catch (error) {
+      this.logError("findInDirectory", error);
+      return [];
+    }
+  }
+  /**
+   * Update custom metadata for a file
+   */
+  async updateMetadata(path3, storageType, metadata) {
+    try {
+      const existing = await this.findByPath(path3, storageType);
+      if (existing) {
+        const currentData = JSON.parse(existing.file_data || "{}");
+        const newData = { ...currentData, ...metadata };
+        await this.crud.updateById(existing.id, {
+          file_data: JSON.stringify(newData),
+          changed_at: this.now()
+        });
+        this.logger?.debug?.("Updated file metadata", { path: path3 });
+        return true;
+      }
+      return false;
+    } catch (error) {
+      this.logError("updateMetadata", error);
+      return false;
+    }
+  }
+};
+function createFileMetadataService(crudService, options) {
+  return new FileMetadataService(crudService, options);
+}
+
+// src/services/tracked-file-manager.ts
+var TrackedFileManager = class extends FileManager {
+  constructor(options = {}) {
+    super(options);
+    this.metadataService = null;
+    this.trackingConfig = {
+      enabled: options.tracking?.enabled ?? false,
+      tableName: options.tracking?.tableName ?? "hazo_files",
+      trackDownloads: options.tracking?.trackDownloads ?? true,
+      logErrors: options.tracking?.logErrors ?? true
+    };
+    if (options.crudService && this.trackingConfig.enabled) {
+      this.metadataService = new FileMetadataService(options.crudService, {
+        tableName: this.trackingConfig.tableName,
+        logErrors: this.trackingConfig.logErrors
+      });
+    }
+  }
+  /**
+   * Check if tracking is enabled and service is available
+   */
+  isTrackingEnabled() {
+    return this.trackingConfig.enabled && this.metadataService !== null;
+  }
+  /**
+   * Get the current storage provider type
+   */
+  getStorageType() {
+    return this.getProvider() || "local";
+  }
+  // ============ Tracked Directory Operations ============
+  /**
+   * Create a directory and record it in the database
+   */
+  async createDirectory(path3) {
+    const result = await super.createDirectory(path3);
+    if (result.success && this.isTrackingEnabled()) {
+      this.metadataService.recordDirectoryCreation(
+        path3,
+        this.getStorageType(),
+        result.data?.metadata
+      ).catch(() => {
+      });
+    }
+    return result;
+  }
+  /**
+   * Remove a directory and delete its record from the database
+   */
+  async removeDirectory(path3, recursive = false) {
+    const result = await super.removeDirectory(path3, recursive);
+    if (result.success && this.isTrackingEnabled()) {
+      this.metadataService.recordDirectoryDelete(
+        path3,
+        this.getStorageType(),
+        recursive
+      ).catch(() => {
+      });
+    }
+    return result;
+  }
+  // ============ Tracked File Operations ============
+  /**
+   * Upload a file and record it in the database
+   */
+  async uploadFile(source, remotePath, options) {
+    const result = await super.uploadFile(source, remotePath, options);
+    if (result.success && this.isTrackingEnabled() && result.data) {
+      const fileItem = result.data;
+      this.metadataService.recordUpload({
+        filename: fileItem.name,
+        file_type: fileItem.mimeType || getMimeType(fileItem.name),
+        file_data: options?.metadata || fileItem.metadata,
+        file_path: remotePath,
+        storage_type: this.getStorageType()
+      }).catch(() => {
+      });
+    }
+    return result;
+  }
+  /**
+   * Download a file and optionally track access
+   */
+  async downloadFile(remotePath, localPath, options) {
+    const result = await super.downloadFile(remotePath, localPath, options);
+    if (result.success && this.isTrackingEnabled() && this.trackingConfig.trackDownloads) {
+      this.metadataService.recordAccess(
+        remotePath,
+        this.getStorageType()
+      ).catch(() => {
+      });
+    }
+    return result;
+  }
+  /**
+   * Move a file or folder and update its path in the database
+   */
+  async moveItem(sourcePath, destinationPath, options) {
+    const result = await super.moveItem(sourcePath, destinationPath, options);
+    if (result.success && this.isTrackingEnabled()) {
+      this.metadataService.recordMove(
+        sourcePath,
+        destinationPath,
+        this.getStorageType()
+      ).catch(() => {
+      });
+    }
+    return result;
+  }
+  /**
+   * Delete a file and remove its record from the database
+   */
+  async deleteFile(path3) {
+    const result = await super.deleteFile(path3);
+    if (result.success && this.isTrackingEnabled()) {
+      this.metadataService.recordDelete(
+        path3,
+        this.getStorageType()
+      ).catch(() => {
+      });
+    }
+    return result;
+  }
+  /**
+   * Rename a file and update its record in the database
+   */
+  async renameFile(path3, newName, options) {
+    const result = await super.renameFile(path3, newName, options);
+    if (result.success && this.isTrackingEnabled()) {
+      this.metadataService.recordRename(
+        path3,
+        newName,
+        this.getStorageType()
+      ).catch(() => {
+      });
+    }
+    return result;
+  }
+  /**
+   * Rename a folder and update its record in the database
+   */
+  async renameFolder(path3, newName, options) {
+    const result = await super.renameFolder(path3, newName, options);
+    if (result.success && this.isTrackingEnabled()) {
+      this.metadataService.recordRename(
+        path3,
+        newName,
+        this.getStorageType()
+      ).catch(() => {
+      });
+    }
+    return result;
+  }
+  // ============ Tracked Convenience Methods ============
+  /**
+   * Write a file with string content and track it
+   */
+  async writeFile(path3, content, options) {
+    const buffer = Buffer.from(content, "utf-8");
+    return this.uploadFile(buffer, path3, options);
+  }
+  /**
+   * Read a file and optionally track access
+   */
+  async readFile(path3) {
+    return super.readFile(path3);
+  }
+  /**
+   * Copy a file and track the new file
+   */
+  async copyFile(sourcePath, destinationPath, options) {
+    return super.copyFile(sourcePath, destinationPath, options);
+  }
+  // ============ Metadata Service Access ============
+  /**
+   * Get the metadata service for direct access
+   */
+  getMetadataService() {
+    return this.metadataService;
+  }
+  /**
+   * Check if database tracking is enabled
+   */
+  isTrackingActive() {
+    return this.isTrackingEnabled();
+  }
+  /**
+   * Get tracking configuration
+   */
+  getTrackingConfig() {
+    return { ...this.trackingConfig };
+  }
+};
+function createTrackedFileManager(options) {
+  return new TrackedFileManager(options);
+}
+async function createInitializedTrackedFileManager(options) {
+  const manager = new TrackedFileManager(options);
+  await manager.initialize();
+  return manager;
+}
+
 // src/common/naming-utils.ts
 var DEFAULT_DATE_FORMATS = [
   "YYYY",
@@ -2374,6 +2820,7 @@ function generatePreviewName(pattern, userVariables, options = {}) {
   DirectoryNotFoundError,
   FileExistsError,
   FileManager,
+  FileMetadataService,
   FileNotFoundError,
   FileTooLargeError,
   GoogleDriveAuth,
@@ -2387,18 +2834,22 @@ function generatePreviewName(pattern, userVariables, options = {}) {
   SYSTEM_COUNTER_VARIABLES,
   SYSTEM_DATE_VARIABLES,
   SYSTEM_FILE_VARIABLES,
+  TrackedFileManager,
   clonePattern,
   createAndInitializeModule,
   createEmptyNamingRuleSchema,
   createFileItem,
   createFileManager,
+  createFileMetadataService,
   createFolderItem,
   createGoogleDriveAuth,
   createGoogleDriveModule,
   createInitializedFileManager,
+  createInitializedTrackedFileManager,
   createLiteralSegment,
   createLocalModule,
   createModule,
+  createTrackedFileManager,
   createVariableSegment,
   errorResult,
   filterItems,
@@ -2454,4 +2905,3 @@ function generatePreviewName(pattern, userVariables, options = {}) {
   validateNamingRuleSchema,
   validatePath
 });
-//# sourceMappingURL=index.js.map