@wener/common 2.0.3 → 2.0.6

package/lib/fs/server/createDatabaseFileSystem.js

@@ -1,750 +1,843 @@
-import { _ as _ts_decorate } from "@swc/helpers/_/_ts_decorate";
-import { _ as _ts_metadata } from "@swc/helpers/_/_ts_metadata";
-import * as crypto from "node:crypto";
-import { basename, dirname, join, normalize } from "node:path";
-import { Cascade, Collection, Entity, ManyToOne, OneToMany, OneToOne, Property, types, Unique } from "@mikro-orm/core";
-import { TenantBaseEntity } from "@wener/server/entity";
-import { getEntityManager } from "@wener/server/mikro-orm";
-import { FileSystemError, FileSystemErrorCode } from "../FileSystemError.js";
-import { FileKind } from "../types.js";
+import * as crypto from 'node:crypto';
+import { basename, dirname, join, normalize } from 'node:path';
+import { Cascade, Collection, Entity, ManyToOne, OneToMany, OneToOne, Property, types, Unique } from '@mikro-orm/core';
+import { _ as _ts_decorate } from '@swc/helpers/_/_ts_decorate';
+import { _ as _ts_metadata } from '@swc/helpers/_/_ts_metadata';
+import { TenantBaseEntity } from '@wener/server/entity';
+import { getEntityManager } from '@wener/server/mikro-orm';
+import { FileSystemError, FileSystemErrorCode } from '../FileSystemError.js';
+import { FileKind } from '../types.js';
 export function createDatabaseFileSystem(options = {}) {
-    return new DBFS(options);
+	return new DBFS(options);
 }
 let DBFS = class DBFS {
-    options;
-    constructor(options = {}) {
-        this.options = {
-            getEntityManager: () => getEntityManager().fork(),
-            smallFileThreshold: 512,
-            ...options
-        };
-    }
-    get em() {
-        return this.options.getEntityManager();
-    }
-    /**
-     * Ensure root node exists, create it if it doesn't exist
-     * @returns The root FileNodeMetaEntity
-     */ async ensureRootNode() {
-        const em = this.em;
-        const rootQb = em.createQueryBuilder(FileNodeMetaEntity, "f");
-        rootQb.where({
-            parent: null
-        });
-        const rootNode = await rootQb.getSingleResult();
-        if (rootNode) {
-            return rootNode;
-        }
-        // Create root directory (parent is null, filename is empty string)
-        const now = new Date();
-        const rootDir = em.create(FileNodeMetaEntity, {
-            filename: "",
-            parent: null,
-            kind: FileKind.directory,
-            size: 0,
-            atime: now,
-            btime: now,
-            ctime: now,
-            mtime: now
-        });
-        try {
-            await em.persistAndFlush(rootDir);
-            return rootDir;
-        }
-        catch (error) {
-            // If root already exists (race condition), fetch and return it
-            if (error.message?.includes("UNIQUE constraint") || error.message?.includes("duplicate")) {
-                const existingRootQb = em.createQueryBuilder(FileNodeMetaEntity, "f");
-                existingRootQb.where({
-                    parent: null
-                });
-                const existingRoot = await existingRootQb.getSingleResult();
-                if (existingRoot) {
-                    return existingRoot;
-                }
-            }
-            throw error;
-        }
-    }
-    async stat(path, options) {
-        // Validate input
-        if (!path || typeof path !== "string") {
-            throw new FileSystemError("Invalid path", FileSystemErrorCode.EINVAL);
-        }
-        const em = this.em;
-        const node = await this._getNodeByPath(path, em);
-        if (!node) {
-            throw new FileSystemError(`Path not found: ${path}`, FileSystemErrorCode.ENOENT);
-        }
-        return this._toFileStat(node, path);
-    }
-    async exists(path) {
-        return !!await this._getNodeByPath(path, this.em);
-    }
-    async readdir(dir, options) {
-        const em = this.em;
-        const parentNode = await this._getNodeByPath(dir, em);
-        if (!parentNode) {
-            throw new FileSystemError(`Directory not found: ${dir}`, FileSystemErrorCode.ENOENT);
-        }
-        if (parentNode.kind !== FileKind.directory) {
-            throw new FileSystemError(`Path is not a directory: ${dir}`, FileSystemErrorCode.ENOTDIR);
-        }
-        // Use QueryBuilder to avoid automatic relationship loading
-        const qb = em.createQueryBuilder(FileNodeMetaEntity, "f");
-        qb.where({
-            parent: parentNode
-        });
-        const children = await qb.getResult();
-        return children.map((child) => this._toFileStat(child, join(dir, child.filename)));
-    }
-    async mkdir(path, options = {}) {
-        await this._mkdirInTransaction(path, options, this.em);
-    }
-    async _mkdirInTransaction(path, options, em) {
-        const normalized = normalize(path);
-        // Special handling for root directory
-        if (normalized === "/") {
-            const rootQb = em.createQueryBuilder(FileNodeMetaEntity, "f");
-            rootQb.where({
-                parent: null
-            });
-            const rootNode = await rootQb.getSingleResult();
-            if (rootNode) {
-                // Root directory already exists
-                return;
-            }
-            // Create root directory (parent is null, filename is empty string)
-            const now = new Date();
-            const rootDir = em.create(FileNodeMetaEntity, {
-                filename: "",
-                parent: null,
-                kind: FileKind.directory,
-                size: 0,
-                atime: now,
-                btime: now,
-                ctime: now,
-                mtime: now
-            });
-            try {
-                await em.persistAndFlush(rootDir);
-            }
-            catch (error) {
-                // If root already exists (race condition), ignore the error
-                if (!error.message?.includes("UNIQUE constraint") && !error.message?.includes("duplicate")) {
-                    throw error;
-                }
-            }
-            return;
-        }
-        const parentPath = dirname(normalized);
-        const newDirName = basename(normalized);
-        if (!newDirName)
-            throw new FileSystemError("Cannot create directory with empty name", FileSystemErrorCode.EINVAL);
-        let parentNode = await this._getNodeByPath(parentPath, em);
-        if (!parentNode) {
-            if (options.recursive) {
-                // 递归创建父目录
-                await this._mkdirInTransaction(parentPath, options, em);
-                parentNode = await this._getNodeByPath(parentPath, em);
-            }
-            else {
-                throw new FileSystemError(`Parent directory not found: ${parentPath}`, FileSystemErrorCode.ENOENT);
-            }
-        }
-        if (!parentNode)
-            throw new FileSystemError("Failed to create parent directory structure", FileSystemErrorCode.EINVAL);
-        // Check if directory already exists using QueryBuilder
-        const existingQb = em.createQueryBuilder(FileNodeMetaEntity, "f");
-        existingQb.where({
-            parent: parentNode,
-            filename: newDirName
-        });
-        const existing = await existingQb.getSingleResult();
-        if (existing) {
-            if (existing.kind === FileKind.directory) {
-                // Directory already exists, return silently
-                return;
-            }
-            throw new FileSystemError(`A file with the same name already exists: ${path}`, FileSystemErrorCode.EEXIST);
-        }
-        // Create directory using EntityManager
-        const now = new Date();
-        const newDir = em.create(FileNodeMetaEntity, {
-            tid: parentNode.tid,
-            parent: parentNode,
-            filename: newDirName,
-            kind: FileKind.directory,
-            size: 0,
-            atime: now,
-            btime: now,
-            ctime: now,
-            mtime: now
-        });
-        await em.persistAndFlush(newDir);
-    }
-    async readFile(path, options) {
-        const em = this.em;
-        const node = await this._getNodeByPath(path, em);
-        if (!node)
-            throw new FileSystemError(`File not found: ${path}`, FileSystemErrorCode.ENOENT);
-        if (node.kind !== FileKind.file)
-            throw new FileSystemError(`Path is not a file: ${path}`, FileSystemErrorCode.EISDIR);
-        let buffer;
-        if (node.content) {
-            // 小文件优化 - content is already loaded
-            buffer = node.content;
-        }
-        else {
-            // Large file: load from file_node_content table using QueryBuilder
-            const fileContentQb = em.createQueryBuilder(FileNodeContentEntity, "fc");
-            fileContentQb.where({
-                node: node
-            });
-            const fileContent = await fileContentQb.getSingleResult();
-            if (!fileContent)
-                throw new FileSystemError("File content is missing", FileSystemErrorCode.ENOENT);
-            buffer = fileContent.content;
-        }
-        return options?.encoding === "text" ? buffer.toString("utf-8") : buffer;
-    }
-    async writeFile(path, data, options = {}) {
-        // Validate input
-        if (!path || typeof path !== "string") {
-            throw new FileSystemError("Invalid path", FileSystemErrorCode.EINVAL);
-        }
-        if (data === null || data === undefined) {
-            throw new FileSystemError("Invalid data", FileSystemErrorCode.EINVAL);
-        }
-        await this.em.transactional(async (em) => {
-            const { overwrite = true } = options;
-            const bufferData = Buffer.isBuffer(data) ? data : Buffer.from(data, "utf-8");
-            const size = bufferData.length;
-            const parentPath = dirname(path);
-            const filename = basename(path);
-            // Validate filename
-            if (!filename) {
-                throw new FileSystemError("filename cannot be empty", FileSystemErrorCode.EINVAL);
-            }
-            // 确保父目录存在 - create it within the transaction
-            await this._mkdirInTransaction(parentPath, {
-                recursive: true
-            }, em);
-            const parentNode = await this._getNodeByPath(parentPath, em);
-            if (!parentNode)
-                throw new FileSystemError("Failed to establish parent directory", FileSystemErrorCode.EINVAL);
-            // Find existing node using QueryBuilder
-            const nodeQb = em.createQueryBuilder(FileNodeMetaEntity, "f");
-            nodeQb.where({
-                parent: parentNode,
-                filename
-            });
-            let node = await nodeQb.getSingleResult();
-            if (node) {
-                // 文件已存在
-                if (!overwrite)
-                    throw new FileSystemError(`File already exists: ${path}`, FileSystemErrorCode.EEXIST);
-                if (node.kind === FileKind.directory)
-                    throw new FileSystemError(`Cannot overwrite a directory with a file: ${path}`, FileSystemErrorCode.EISDIR);
-                // 更新节点
-                node.size = size;
-                node.mtime = new Date();
-                // ... 其他时间戳
-            }
-            else {
-                // 新建文件
-                const now = new Date();
-                node = em.create(FileNodeMetaEntity, {
-                    tid: parentNode.tid,
-                    filename,
-                    parent: parentNode,
-                    kind: FileKind.file,
-                    size,
-                    atime: now,
-                    btime: now,
-                    ctime: now,
-                    mtime: now
-                });
-            }
-            // 处理文件内容
-            if (size <= this.options.smallFileThreshold) {
-                // Small file: store in file_node_meta.content
-                node.content = bufferData;
-                // If there was large file content, delete it
-                // Use QueryBuilder to avoid relationship issues
-                const existingContentQb = em.createQueryBuilder(FileNodeContentEntity, "fc");
-                existingContentQb.where({
-                    node: node
-                });
-                const existingContent = await existingContentQb.getSingleResult();
-                if (existingContent) {
-                    await em.removeAndFlush(existingContent);
-                }
-            }
-            else {
-                // Large file: store in file_node_content table
-                node.content = undefined; // Clear small file content
-                const md5 = crypto.createHash("md5").update(bufferData).digest("hex");
-                const sha256 = crypto.createHash("sha256").update(bufferData).digest("hex");
-                // Check if fileContent already exists using QueryBuilder
-                const fileContentQb = em.createQueryBuilder(FileNodeContentEntity, "fc");
-                fileContentQb.where({
-                    node: node
-                });
-                let fileContent = await fileContentQb.getSingleResult();
-                if (fileContent) {
-                    // Update existing content
-                    fileContent.content = bufferData;
-                    fileContent.size = size;
-                    fileContent.md5 = md5;
-                    fileContent.sha256 = sha256;
-                }
-                else {
-                    // Create new content entity
-                    fileContent = em.create(FileNodeContentEntity, {
-                        node: node,
-                        tid: node.tid,
-                        content: bufferData,
-                        size: size,
-                        md5: md5,
-                        sha256: sha256
-                    });
-                }
-            }
-            await em.persistAndFlush(node);
-        });
-    }
-    async rm(path, options = {}) {
-        await this.em.transactional(async (em) => {
-            const node = await this._getNodeByPath(path, em);
-            if (!node) {
-                if (options.force)
-                    return; // force=true, 不存在也算成功
-                throw new FileSystemError(`Path not found: ${path}`, FileSystemErrorCode.ENOENT);
-            }
-            if (node.kind === FileKind.directory && !options.recursive) {
-                // Check if directory has children using QueryBuilder
-                const childrenQb = em.createQueryBuilder(FileNodeMetaEntity, "f");
-                childrenQb.where({
-                    parent: node
-                });
-                childrenQb.select("id");
-                const children = await childrenQb.getResult();
-                if (children.length > 0) {
-                    throw new FileSystemError(`Directory not empty: ${path}`, FileSystemErrorCode.ENOTEMPTY);
-                }
-            }
-            // 使用 orphanRemoval: true, ORM会自动处理子节点和内容的删除
-            await em.removeAndFlush(node);
-        });
-    }
-    async rename(oldPath, newPath, options = {}) {
-        await this.em.transactional(async (em) => {
-            const node = await this._getNodeByPath(oldPath, em);
-            if (!node)
-                throw new FileSystemError(`Source path not found: ${oldPath}`, FileSystemErrorCode.ENOENT);
-            const newParentPath = dirname(newPath);
-            const newFilename = basename(newPath);
-            const newParentNode = await this._getNodeByPath(newParentPath, em);
-            if (!newParentNode)
-                throw new FileSystemError(`Destination directory not found: ${newParentPath}`, FileSystemErrorCode.ENOENT);
-            const existingDestQb = em.createQueryBuilder(FileNodeMetaEntity, "f");
-            existingDestQb.where({
-                parent: newParentNode,
-                filename: newFilename
-            });
-            const existingDest = await existingDestQb.getSingleResult();
-            if (existingDest) {
-                if (!options.overwrite)
-                    throw new FileSystemError(`Destination path already exists: ${newPath}`, FileSystemErrorCode.EEXIST);
-                if (node.id === existingDest.id)
-                    return; // 移动到原位置，什么都不做
-                await em.removeAndFlush(existingDest);
-            }
-            node.parent = newParentNode;
-            node.filename = newFilename;
-            node.mtime = new Date();
-            await em.flush();
-        });
-    }
-    async copy(srcPath, destPath, options = {}) {
-        await this.em.transactional(async (em) => {
-            const srcNode = await this._getNodeByPath(srcPath, em);
-            if (!srcNode)
-                throw new FileSystemError(`Source path not found: ${srcPath}`, FileSystemErrorCode.ENOENT);
-            const destParentPath = dirname(destPath);
-            const destFilename = basename(destPath);
-            const destParentNode = await this._getNodeByPath(destParentPath, em);
-            if (!destParentNode)
-                throw new FileSystemError(`Destination directory not found: ${destParentPath}`, FileSystemErrorCode.ENOENT);
-            const existingDestQb = em.createQueryBuilder(FileNodeMetaEntity, "f");
-            existingDestQb.where({
-                parent: destParentNode,
-                filename: destFilename
-            });
-            const existingDest = await existingDestQb.getSingleResult();
-            if (existingDest) {
-                if (!options.overwrite)
-                    throw new FileSystemError(`Destination path already exists: ${destPath}`, FileSystemErrorCode.EEXIST);
-                // Delete existing destination within the same transaction
-                await em.removeAndFlush(existingDest);
-            }
-            await this._copyNode(srcNode, destParentNode, destFilename, em);
-        });
-    }
-    createReadStream(path, options) {
-        throw new Error("Streaming read is not supported by DBFS yet.");
-    }
-    createWriteStream(path, options) {
-        throw new Error("Streaming write is not supported by DBFS yet.");
-    }
-    createReadableStream(path, options) {
-        throw new Error("ReadableStream is not supported by DBFS yet.");
-    }
-    createWritableStream(path, options) {
-        throw new Error("WritableStream is not supported by DBFS yet.");
-    }
-    /**
-     * 将路径字符串解析为数据库中的节点。这是大部分操作的基础。
-     * @param pathStr 绝对路径, e.g., /home/user/file.txt
-     * @param em EntityManager 实例
-     * @returns 找到的节点或 null
-     */ async _getNodeByPath(pathStr, em) {
-        const normalized = normalize(pathStr);
-        if (normalized === "/") {
-            // Use QueryBuilder to avoid automatic relationship loading
-            const qb = em.createQueryBuilder(FileNodeMetaEntity, "f");
-            qb.where({
-                parent: null
-            });
-            const rootNode = await qb.getSingleResult();
-            return rootNode || null;
-        }
-        const parts = normalized.split("/").filter((p) => p);
-        // Get root node
-        const rootQb = em.createQueryBuilder(FileNodeMetaEntity, "f");
-        rootQb.where({
-            parent: null
-        });
-        let currentNode = await rootQb.getSingleResult();
-        if (!currentNode)
-            return null;
-        // Traverse path parts
-        for (const part of parts) {
-            const childQb = em.createQueryBuilder(FileNodeMetaEntity, "f");
-            childQb.where({
-                parent: currentNode,
-                filename: part
-            });
-            const child = await childQb.getSingleResult();
-            if (!child)
-                return null;
-            currentNode = child;
-        }
-        return currentNode;
-    }
-    /**
-     * 将数据库实体转换为 IFileStat 接口
-     */ _toFileStat(node, path) {
-        // Handle mtime - it might be a Date object or a string from raw query
-        let mtime;
-        if (node.mtime instanceof Date) {
-            mtime = node.mtime.getTime();
-        }
-        else if (typeof node.mtime === "string") {
-            mtime = new Date(node.mtime).getTime();
-        }
-        else {
-            mtime = Date.now();
-        }
-        // Handle size - convert bigint to number if needed
-        let size;
-        if (typeof node.size === "bigint") {
-            size = Number(node.size);
-        }
-        else {
-            size = node.size;
-        }
-        return {
-            path: path,
-            name: node.filename,
-            kind: node.kind,
-            size: size,
-            mtime: mtime,
-            meta: node.metadata || {},
-            // `directory` 字段可以根据 path 动态计算
-            directory: dirname(path)
-        };
-    }
-    async _copyNode(srcNode, destParent, newName, em) {
-        // 1. 复制节点本身
-        const now = new Date();
-        const newNode = em.create(FileNodeMetaEntity, {
-            tid: srcNode.tid,
-            filename: newName,
-            parent: destParent,
-            kind: srcNode.kind,
-            size: srcNode.size,
-            metadata: srcNode.metadata,
-            content: srcNode.content,
-            atime: now,
-            btime: now,
-            ctime: now,
-            mtime: now
-        });
-        // 2. 复制大文件内容 (如果存在) - use QueryBuilder to avoid relationship loading
-        if (!srcNode.content) {
-            const srcFileContentQb = em.createQueryBuilder(FileNodeContentEntity, "fc");
-            srcFileContentQb.where({
-                node: srcNode
-            });
-            const srcFileContent = await srcFileContentQb.getSingleResult();
-            if (srcFileContent) {
-                const newContent = em.create(FileNodeContentEntity, {
-                    node: newNode,
-                    tid: srcNode.tid,
-                    content: srcFileContent.content,
-                    size: srcFileContent.size,
-                    md5: srcFileContent.md5,
-                    sha256: srcFileContent.sha256,
-                    mimeType: srcFileContent.mimeType,
-                    metadata: srcFileContent.metadata
-                });
-            }
-        }
-        await em.persistAndFlush(newNode);
-        // 3. 如果是目录，递归复制子节点
-        if (srcNode.kind === FileKind.directory) {
-            const childrenQb = em.createQueryBuilder(FileNodeMetaEntity, "f");
-            childrenQb.where({
-                parent: srcNode
-            });
-            const children = await childrenQb.getResult();
-            for (const child of children) {
-                await this._copyNode(child, newNode, child.filename, em);
-            }
-        }
-    }
+	options;
+	constructor(options = {}) {
+		this.options = {
+			getEntityManager: () => getEntityManager().fork(),
+			smallFileThreshold: 512,
+			...options,
+		};
+	}
+	get em() {
+		return this.options.getEntityManager();
+	}
+	/**
+	 * Ensure root node exists, create it if it doesn't exist
+	 * @returns The root FileNodeMetaEntity
+	 */ async ensureRootNode() {
+		const em = this.em;
+		const rootQb = em.createQueryBuilder(FileNodeMetaEntity, 'f');
+		rootQb.where({
+			parent: null,
+		});
+		const rootNode = await rootQb.getSingleResult();
+		if (rootNode) {
+			return rootNode;
+		}
+		// Create root directory (parent is null, filename is empty string)
+		const now = new Date();
+		const rootDir = em.create(FileNodeMetaEntity, {
+			filename: '',
+			parent: null,
+			kind: FileKind.directory,
+			size: 0,
+			atime: now,
+			btime: now,
+			ctime: now,
+			mtime: now,
+		});
+		try {
+			await em.persistAndFlush(rootDir);
+			return rootDir;
+		} catch (error) {
+			// If root already exists (race condition), fetch and return it
+			if (error.message?.includes('UNIQUE constraint') || error.message?.includes('duplicate')) {
+				const existingRootQb = em.createQueryBuilder(FileNodeMetaEntity, 'f');
+				existingRootQb.where({
+					parent: null,
+				});
+				const existingRoot = await existingRootQb.getSingleResult();
+				if (existingRoot) {
+					return existingRoot;
+				}
+			}
+			throw error;
+		}
+	}
+	async stat(path, _options) {
+		// Validate input
+		if (!path || typeof path !== 'string') {
+			throw new FileSystemError('Invalid path', FileSystemErrorCode.EINVAL);
+		}
+		const em = this.em;
+		const node = await this._getNodeByPath(path, em);
+		if (!node) {
+			throw new FileSystemError(`Path not found: ${path}`, FileSystemErrorCode.ENOENT);
+		}
+		return this._toFileStat(node, path);
+	}
+	async exists(path) {
+		return !!(await this._getNodeByPath(path, this.em));
+	}
+	async readdir(dir, _options) {
+		const em = this.em;
+		const parentNode = await this._getNodeByPath(dir, em);
+		if (!parentNode) {
+			throw new FileSystemError(`Directory not found: ${dir}`, FileSystemErrorCode.ENOENT);
+		}
+		if (parentNode.kind !== FileKind.directory) {
+			throw new FileSystemError(`Path is not a directory: ${dir}`, FileSystemErrorCode.ENOTDIR);
+		}
+		// Use QueryBuilder to avoid automatic relationship loading
+		const qb = em.createQueryBuilder(FileNodeMetaEntity, 'f');
+		qb.where({
+			parent: parentNode,
+		});
+		const children = await qb.getResult();
+		return children.map((child) => this._toFileStat(child, join(dir, child.filename)));
+	}
+	async mkdir(path, options = {}) {
+		await this._mkdirInTransaction(path, options, this.em);
+	}
+	async _mkdirInTransaction(path, options, em) {
+		const normalized = normalize(path);
+		// Special handling for root directory
+		if (normalized === '/') {
+			const rootQb = em.createQueryBuilder(FileNodeMetaEntity, 'f');
+			rootQb.where({
+				parent: null,
+			});
+			const rootNode = await rootQb.getSingleResult();
+			if (rootNode) {
+				// Root directory already exists
+				return;
+			}
+			// Create root directory (parent is null, filename is empty string)
+			const now = new Date();
+			const rootDir = em.create(FileNodeMetaEntity, {
+				filename: '',
+				parent: null,
+				kind: FileKind.directory,
+				size: 0,
+				atime: now,
+				btime: now,
+				ctime: now,
+				mtime: now,
+			});
+			try {
+				await em.persistAndFlush(rootDir);
+			} catch (error) {
+				// If root already exists (race condition), ignore the error
+				if (!error.message?.includes('UNIQUE constraint') && !error.message?.includes('duplicate')) {
+					throw error;
+				}
+			}
+			return;
+		}
+		const parentPath = dirname(normalized);
+		const newDirName = basename(normalized);
+		if (!newDirName) throw new FileSystemError('Cannot create directory with empty name', FileSystemErrorCode.EINVAL);
+		let parentNode = await this._getNodeByPath(parentPath, em);
+		if (!parentNode) {
+			if (options.recursive) {
+				// 递归创建父目录
+				await this._mkdirInTransaction(parentPath, options, em);
+				parentNode = await this._getNodeByPath(parentPath, em);
+			} else {
+				throw new FileSystemError(`Parent directory not found: ${parentPath}`, FileSystemErrorCode.ENOENT);
+			}
+		}
+		if (!parentNode)
+			throw new FileSystemError('Failed to create parent directory structure', FileSystemErrorCode.EINVAL);
+		// Check if directory already exists using QueryBuilder
+		const existingQb = em.createQueryBuilder(FileNodeMetaEntity, 'f');
+		existingQb.where({
+			parent: parentNode,
+			filename: newDirName,
+		});
+		const existing = await existingQb.getSingleResult();
+		if (existing) {
+			if (existing.kind === FileKind.directory) {
+				// Directory already exists, return silently
+				return;
+			}
+			throw new FileSystemError(`A file with the same name already exists: ${path}`, FileSystemErrorCode.EEXIST);
+		}
+		// Create directory using EntityManager
+		const now = new Date();
+		const newDir = em.create(FileNodeMetaEntity, {
+			tid: parentNode.tid,
+			parent: parentNode,
+			filename: newDirName,
+			kind: FileKind.directory,
+			size: 0,
+			atime: now,
+			btime: now,
+			ctime: now,
+			mtime: now,
+		});
+		await em.persistAndFlush(newDir);
+	}
+	async readFile(path, options) {
+		const em = this.em;
+		const node = await this._getNodeByPath(path, em);
+		if (!node) throw new FileSystemError(`File not found: ${path}`, FileSystemErrorCode.ENOENT);
+		if (node.kind !== FileKind.file)
+			throw new FileSystemError(`Path is not a file: ${path}`, FileSystemErrorCode.EISDIR);
+		let buffer;
+		if (node.content) {
+			// 小文件优化 - content is already loaded
+			buffer = node.content;
+		} else {
+			// Large file: load from file_node_content table using QueryBuilder
+			const fileContentQb = em.createQueryBuilder(FileNodeContentEntity, 'fc');
+			fileContentQb.where({
+				node: node,
+			});
+			const fileContent = await fileContentQb.getSingleResult();
+			if (!fileContent) throw new FileSystemError('File content is missing', FileSystemErrorCode.ENOENT);
+			buffer = fileContent.content;
+		}
+		return options?.encoding === 'text' ? buffer.toString('utf-8') : buffer;
+	}
+	async writeFile(path, data, options = {}) {
+		// Validate input
+		if (!path || typeof path !== 'string') {
+			throw new FileSystemError('Invalid path', FileSystemErrorCode.EINVAL);
+		}
+		if (data === null || data === undefined) {
+			throw new FileSystemError('Invalid data', FileSystemErrorCode.EINVAL);
+		}
+		await this.em.transactional(async (em) => {
+			const { overwrite = true } = options;
+			const bufferData = Buffer.isBuffer(data) ? data : Buffer.from(data, 'utf-8');
+			const size = bufferData.length;
+			const parentPath = dirname(path);
+			const filename = basename(path);
+			// Validate filename
+			if (!filename) {
+				throw new FileSystemError('filename cannot be empty', FileSystemErrorCode.EINVAL);
+			}
+			// 确保父目录存在 - create it within the transaction
+			await this._mkdirInTransaction(
+				parentPath,
+				{
+					recursive: true,
+				},
+				em,
+			);
+			const parentNode = await this._getNodeByPath(parentPath, em);
+			if (!parentNode) throw new FileSystemError('Failed to establish parent directory', FileSystemErrorCode.EINVAL);
+			// Find existing node using QueryBuilder
+			const nodeQb = em.createQueryBuilder(FileNodeMetaEntity, 'f');
+			nodeQb.where({
+				parent: parentNode,
+				filename,
+			});
+			let node = await nodeQb.getSingleResult();
+			if (node) {
+				// 文件已存在
+				if (!overwrite) throw new FileSystemError(`File already exists: ${path}`, FileSystemErrorCode.EEXIST);
+				if (node.kind === FileKind.directory)
+					throw new FileSystemError(`Cannot overwrite a directory with a file: ${path}`, FileSystemErrorCode.EISDIR);
+				// 更新节点
+				node.size = size;
+				node.mtime = new Date();
+				// ... 其他时间戳
+			} else {
+				// 新建文件
+				const now = new Date();
+				node = em.create(FileNodeMetaEntity, {
+					tid: parentNode.tid,
+					filename,
+					parent: parentNode,
+					kind: FileKind.file,
+					size,
+					atime: now,
+					btime: now,
+					ctime: now,
+					mtime: now,
+				});
+			}
+			// 处理文件内容
+			if (size <= this.options.smallFileThreshold) {
+				// Small file: store in file_node_meta.content
+				node.content = bufferData;
+				// If there was large file content, delete it
+				// Use QueryBuilder to avoid relationship issues
+				const existingContentQb = em.createQueryBuilder(FileNodeContentEntity, 'fc');
+				existingContentQb.where({
+					node: node,
+				});
+				const existingContent = await existingContentQb.getSingleResult();
+				if (existingContent) {
+					await em.removeAndFlush(existingContent);
+				}
+			} else {
+				// Large file: store in file_node_content table
+				node.content = undefined; // Clear small file content
+				const md5 = crypto.createHash('md5').update(bufferData).digest('hex');
+				const sha256 = crypto.createHash('sha256').update(bufferData).digest('hex');
+				// Check if fileContent already exists using QueryBuilder
+				const fileContentQb = em.createQueryBuilder(FileNodeContentEntity, 'fc');
+				fileContentQb.where({
+					node: node,
+				});
+				let fileContent = await fileContentQb.getSingleResult();
+				if (fileContent) {
+					// Update existing content
+					fileContent.content = bufferData;
+					fileContent.size = size;
+					fileContent.md5 = md5;
+					fileContent.sha256 = sha256;
+				} else {
+					// Create new content entity
+					fileContent = em.create(FileNodeContentEntity, {
+						node: node,
+						tid: node.tid,
+						content: bufferData,
+						size: size,
+						md5: md5,
+						sha256: sha256,
+					});
+				}
+			}
+			await em.persistAndFlush(node);
+		});
+	}
+	async rm(path, options = {}) {
+		await this.em.transactional(async (em) => {
+			const node = await this._getNodeByPath(path, em);
+			if (!node) {
+				if (options.force) return; // force=true, 不存在也算成功
+				throw new FileSystemError(`Path not found: ${path}`, FileSystemErrorCode.ENOENT);
+			}
+			if (node.kind === FileKind.directory && !options.recursive) {
+				// Check if directory has children using QueryBuilder
+				const childrenQb = em.createQueryBuilder(FileNodeMetaEntity, 'f');
+				childrenQb.where({
+					parent: node,
+				});
+				childrenQb.select('id');
+				const children = await childrenQb.getResult();
+				if (children.length > 0) {
+					throw new FileSystemError(`Directory not empty: ${path}`, FileSystemErrorCode.ENOTEMPTY);
+				}
+			}
+			// 使用 orphanRemoval: true, ORM会自动处理子节点和内容的删除
+			await em.removeAndFlush(node);
+		});
+	}
+	async rename(oldPath, newPath, options = {}) {
+		await this.em.transactional(async (em) => {
+			const node = await this._getNodeByPath(oldPath, em);
+			if (!node) throw new FileSystemError(`Source path not found: ${oldPath}`, FileSystemErrorCode.ENOENT);
+			const newParentPath = dirname(newPath);
+			const newFilename = basename(newPath);
+			const newParentNode = await this._getNodeByPath(newParentPath, em);
+			if (!newParentNode)
+				throw new FileSystemError(`Destination directory not found: ${newParentPath}`, FileSystemErrorCode.ENOENT);
+			const existingDestQb = em.createQueryBuilder(FileNodeMetaEntity, 'f');
+			existingDestQb.where({
+				parent: newParentNode,
+				filename: newFilename,
+			});
+			const existingDest = await existingDestQb.getSingleResult();
+			if (existingDest) {
+				if (!options.overwrite)
+					throw new FileSystemError(`Destination path already exists: ${newPath}`, FileSystemErrorCode.EEXIST);
+				if (node.id === existingDest.id) return; // 移动到原位置，什么都不做
+				await em.removeAndFlush(existingDest);
+			}
+			node.parent = newParentNode;
+			node.filename = newFilename;
+			node.mtime = new Date();
+			await em.flush();
+		});
+	}
+	async copy(srcPath, destPath, options = {}) {
+		await this.em.transactional(async (em) => {
+			const srcNode = await this._getNodeByPath(srcPath, em);
+			if (!srcNode) throw new FileSystemError(`Source path not found: ${srcPath}`, FileSystemErrorCode.ENOENT);
+			const destParentPath = dirname(destPath);
+			const destFilename = basename(destPath);
+			const destParentNode = await this._getNodeByPath(destParentPath, em);
+			if (!destParentNode)
+				throw new FileSystemError(`Destination directory not found: ${destParentPath}`, FileSystemErrorCode.ENOENT);
+			const existingDestQb = em.createQueryBuilder(FileNodeMetaEntity, 'f');
+			existingDestQb.where({
+				parent: destParentNode,
+				filename: destFilename,
+			});
+			const existingDest = await existingDestQb.getSingleResult();
+			if (existingDest) {
+				if (!options.overwrite)
+					throw new FileSystemError(`Destination path already exists: ${destPath}`, FileSystemErrorCode.EEXIST);
+				// Delete existing destination within the same transaction
+				await em.removeAndFlush(existingDest);
+			}
+			await this._copyNode(srcNode, destParentNode, destFilename, em);
+		});
+	}
+	createReadStream(_path, _options) {
+		throw new Error('Streaming read is not supported by DBFS yet.');
+	}
+	createWriteStream(_path, _options) {
+		throw new Error('Streaming write is not supported by DBFS yet.');
+	}
+	createReadableStream(_path, _options) {
+		throw new Error('ReadableStream is not supported by DBFS yet.');
+	}
+	createWritableStream(_path, _options) {
+		throw new Error('WritableStream is not supported by DBFS yet.');
+	}
+	/**
+	 * 将路径字符串解析为数据库中的节点。这是大部分操作的基础。
+	 * @param pathStr 绝对路径, e.g., /home/user/file.txt
+	 * @param em EntityManager 实例
+	 * @returns 找到的节点或 null
+	 */ async _getNodeByPath(pathStr, em) {
+		const normalized = normalize(pathStr);
+		if (normalized === '/') {
+			// Use QueryBuilder to avoid automatic relationship loading
+			const qb = em.createQueryBuilder(FileNodeMetaEntity, 'f');
+			qb.where({
+				parent: null,
+			});
+			const rootNode = await qb.getSingleResult();
+			return rootNode || null;
+		}
+		const parts = normalized.split('/').filter((p) => p);
+		// Get root node
+		const rootQb = em.createQueryBuilder(FileNodeMetaEntity, 'f');
+		rootQb.where({
+			parent: null,
+		});
+		let currentNode = await rootQb.getSingleResult();
+		if (!currentNode) return null;
+		// Traverse path parts
+		for (const part of parts) {
+			const childQb = em.createQueryBuilder(FileNodeMetaEntity, 'f');
+			childQb.where({
+				parent: currentNode,
+				filename: part,
+			});
+			const child = await childQb.getSingleResult();
+			if (!child) return null;
+			currentNode = child;
+		}
+		return currentNode;
+	}
+	/**
+	 * 将数据库实体转换为 IFileStat 接口
+	 */ _toFileStat(node, path) {
+		// Handle mtime - it might be a Date object or a string from raw query
+		let mtime;
+		if (node.mtime instanceof Date) {
+			mtime = node.mtime.getTime();
+		} else if (typeof node.mtime === 'string') {
+			mtime = new Date(node.mtime).getTime();
+		} else {
+			mtime = Date.now();
+		}
+		// Handle size - convert bigint to number if needed
+		let size;
+		if (typeof node.size === 'bigint') {
+			size = Number(node.size);
+		} else {
+			size = node.size;
+		}
+		return {
+			path: path,
+			name: node.filename,
+			kind: node.kind,
+			size: size,
+			mtime: mtime,
+			meta: node.metadata || {},
+			// `directory` 字段可以根据 path 动态计算
+			directory: dirname(path),
+		};
+	}
+	async _copyNode(srcNode, destParent, newName, em) {
+		// 1. 复制节点本身
+		const now = new Date();
+		const newNode = em.create(FileNodeMetaEntity, {
+			tid: srcNode.tid,
+			filename: newName,
+			parent: destParent,
+			kind: srcNode.kind,
+			size: srcNode.size,
+			metadata: srcNode.metadata,
+			content: srcNode.content,
+			atime: now,
+			btime: now,
+			ctime: now,
+			mtime: now,
+		});
+		// 2. 复制大文件内容 (如果存在) - use QueryBuilder to avoid relationship loading
+		if (!srcNode.content) {
+			const srcFileContentQb = em.createQueryBuilder(FileNodeContentEntity, 'fc');
+			srcFileContentQb.where({
+				node: srcNode,
+			});
+			const srcFileContent = await srcFileContentQb.getSingleResult();
+			if (srcFileContent) {
+				const _newContent = em.create(FileNodeContentEntity, {
+					node: newNode,
+					tid: srcNode.tid,
+					content: srcFileContent.content,
+					size: srcFileContent.size,
+					md5: srcFileContent.md5,
+					sha256: srcFileContent.sha256,
+					mimeType: srcFileContent.mimeType,
+					metadata: srcFileContent.metadata,
+				});
+			}
+		}
+		await em.persistAndFlush(newNode);
+		// 3. 如果是目录，递归复制子节点
+		if (srcNode.kind === FileKind.directory) {
+			const childrenQb = em.createQueryBuilder(FileNodeMetaEntity, 'f');
+			childrenQb.where({
+				parent: srcNode,
+			});
+			const children = await childrenQb.getResult();
+			for (const child of children) {
+				await this._copyNode(child, newNode, child.filename, em);
+			}
+		}
+	}
 };
 export class FileNodeMetaEntity extends TenantBaseEntity {
-    filename;
-    size;
-    kind;
-    atime;
-    btime;
-    ctime;
-    mtime;
-    metadata;
-    parent;
-    children = new Collection(this);
-    fileContent;
-    content;
-    //region content
-    get parentId() {
-        return this.parent?.id;
-    }
+	filename;
+	size;
+	kind;
+	atime;
+	btime;
+	ctime;
+	mtime;
+	metadata;
+	parent;
+	children = new Collection(this);
+	fileContent;
+	content;
+	//region content
+	get parentId() {
+		return this.parent?.id;
+	}
 }
-_ts_decorate([
-    Property({
-        type: types.string,
-        nullable: false,
-        comment: "\u6587\u4EF6\u540D"
-    }),
-    _ts_metadata("design:type", String)
-], FileNodeMetaEntity.prototype, "filename", void 0);
-_ts_decorate([
-    Property({
-        type: types.bigint,
-        nullable: false,
-        default: 0,
-        comment: "\u6587\u4EF6\u5927\u5C0F"
-    }),
-    _ts_metadata("design:type", Object)
-], FileNodeMetaEntity.prototype, "size", void 0);
-_ts_decorate([
-    Property({
-        type: types.string,
-        nullable: false,
-        comment: "\u6587\u4EF6\u7C7B\u578B"
-    }),
-    _ts_metadata("design:type", typeof FileKind === "undefined" ? Object : FileKind)
-], FileNodeMetaEntity.prototype, "kind", void 0);
-_ts_decorate([
-    Property({
-        type: types.datetime,
-        nullable: false,
-        defaultRaw: "CURRENT_TIMESTAMP"
-    }),
-    _ts_metadata("design:type", Object)
-], FileNodeMetaEntity.prototype, "atime", void 0);
-_ts_decorate([
-    Property({
-        type: types.datetime,
-        nullable: false,
-        defaultRaw: "CURRENT_TIMESTAMP"
-    }),
-    _ts_metadata("design:type", Object)
-], FileNodeMetaEntity.prototype, "btime", void 0);
-_ts_decorate([
-    Property({
-        type: types.datetime,
-        nullable: false,
-        defaultRaw: "CURRENT_TIMESTAMP"
-    }),
-    _ts_metadata("design:type", Object)
-], FileNodeMetaEntity.prototype, "ctime", void 0);
-_ts_decorate([
-    Property({
-        type: types.datetime,
-        nullable: false,
-        defaultRaw: "CURRENT_TIMESTAMP"
-    }),
-    _ts_metadata("design:type", Object)
-], FileNodeMetaEntity.prototype, "mtime", void 0);
-_ts_decorate([
-    Property({
-        type: types.json,
-        nullable: false,
-        defaultRaw: "{}"
-    }),
-    _ts_metadata("design:type", typeof Record === "undefined" ? Object : Record)
-], FileNodeMetaEntity.prototype, "metadata", void 0);
-_ts_decorate([
-    ManyToOne(() => FileNodeMetaEntity, {
-        nullable: true,
-        cascade: []
-    }),
-    _ts_metadata("design:type", typeof Rel === "undefined" ? Object : Rel)
-], FileNodeMetaEntity.prototype, "parent", void 0);
-_ts_decorate([
-    OneToMany({
-        entity: () => FileNodeMetaEntity,
-        mappedBy: "parent",
-        orphanRemoval: true
-    })
-], FileNodeMetaEntity.prototype, "children", void 0);
-_ts_decorate([
-    OneToOne({
-        entity: () => FileNodeContentEntity,
-        mappedBy: "node",
-        orphanRemoval: true,
-        nullable: true,
-        cascade: [
-            Cascade.ALL
-        ]
-    }),
-    _ts_metadata("design:type", typeof Rel === "undefined" ? Object : Rel)
-], FileNodeMetaEntity.prototype, "fileContent", void 0);
-_ts_decorate([
-    Property({
-        type: types.blob,
-        nullable: true,
-        comment: "\u6587\u4EF6\u5185\u5BB9"
-    }),
-    _ts_metadata("design:type", typeof Buffer === "undefined" ? Object : Buffer)
-], FileNodeMetaEntity.prototype, "content", void 0);
-FileNodeMetaEntity = _ts_decorate([
-    Entity({
-        tableName: "file_node_meta"
-    }),
-    Unique({
-        properties: [
-            "tid",
-            "parent",
-            "filename"
-        ]
-    })
-], FileNodeMetaEntity);
+_ts_decorate(
+	[
+		Property({
+			type: types.string,
+			nullable: false,
+			comment: '\u6587\u4EF6\u540D',
+		}),
+		_ts_metadata('design:type', String),
+	],
+	FileNodeMetaEntity.prototype,
+	'filename',
+	void 0,
+);
+_ts_decorate(
+	[
+		Property({
+			type: types.bigint,
+			nullable: false,
+			default: 0,
+			comment: '\u6587\u4EF6\u5927\u5C0F',
+		}),
+		_ts_metadata('design:type', Object),
+	],
+	FileNodeMetaEntity.prototype,
+	'size',
+	void 0,
+);
+_ts_decorate(
+	[
+		Property({
+			type: types.string,
+			nullable: false,
+			comment: '\u6587\u4EF6\u7C7B\u578B',
+		}),
+		_ts_metadata('design:type', typeof FileKind === 'undefined' ? Object : FileKind),
+	],
+	FileNodeMetaEntity.prototype,
+	'kind',
+	void 0,
+);
+_ts_decorate(
+	[
+		Property({
+			type: types.datetime,
+			nullable: false,
+			defaultRaw: 'CURRENT_TIMESTAMP',
+		}),
+		_ts_metadata('design:type', Object),
+	],
+	FileNodeMetaEntity.prototype,
+	'atime',
+	void 0,
+);
+_ts_decorate(
+	[
+		Property({
+			type: types.datetime,
+			nullable: false,
+			defaultRaw: 'CURRENT_TIMESTAMP',
+		}),
+		_ts_metadata('design:type', Object),
+	],
+	FileNodeMetaEntity.prototype,
+	'btime',
+	void 0,
+);
+_ts_decorate(
+	[
+		Property({
+			type: types.datetime,
+			nullable: false,
+			defaultRaw: 'CURRENT_TIMESTAMP',
+		}),
+		_ts_metadata('design:type', Object),
+	],
+	FileNodeMetaEntity.prototype,
+	'ctime',
+	void 0,
+);
+_ts_decorate(
+	[
+		Property({
+			type: types.datetime,
+			nullable: false,
+			defaultRaw: 'CURRENT_TIMESTAMP',
+		}),
+		_ts_metadata('design:type', Object),
+	],
+	FileNodeMetaEntity.prototype,
+	'mtime',
+	void 0,
+);
+_ts_decorate(
+	[
+		Property({
+			type: types.json,
+			nullable: false,
+			defaultRaw: '{}',
+		}),
+		_ts_metadata('design:type', typeof Record === 'undefined' ? Object : Record),
+	],
+	FileNodeMetaEntity.prototype,
+	'metadata',
+	void 0,
+);
+_ts_decorate(
+	[
+		ManyToOne(() => FileNodeMetaEntity, {
+			nullable: true,
+			cascade: [],
+		}),
+		_ts_metadata('design:type', typeof Rel === 'undefined' ? Object : Rel),
+	],
+	FileNodeMetaEntity.prototype,
+	'parent',
+	void 0,
+);
+_ts_decorate(
+	[
+		OneToMany({
+			entity: () => FileNodeMetaEntity,
+			mappedBy: 'parent',
+			orphanRemoval: true,
+		}),
+	],
+	FileNodeMetaEntity.prototype,
+	'children',
+	void 0,
+);
+_ts_decorate(
+	[
+		OneToOne({
+			entity: () => FileNodeContentEntity,
+			mappedBy: 'node',
+			orphanRemoval: true,
+			nullable: true,
+			cascade: [Cascade.ALL],
+		}),
+		_ts_metadata('design:type', typeof Rel === 'undefined' ? Object : Rel),
+	],
+	FileNodeMetaEntity.prototype,
+	'fileContent',
+	void 0,
+);
+_ts_decorate(
+	[
+		Property({
+			type: types.blob,
+			nullable: true,
+			comment: '\u6587\u4EF6\u5185\u5BB9',
+		}),
+		_ts_metadata('design:type', typeof Buffer === 'undefined' ? Object : Buffer),
+	],
+	FileNodeMetaEntity.prototype,
+	'content',
+	void 0,
+);
+FileNodeMetaEntity = _ts_decorate(
+	[
+		Entity({
+			tableName: 'file_node_meta',
+		}),
+		Unique({
+			properties: ['tid', 'parent', 'filename'],
+		}),
+	],
+	FileNodeMetaEntity,
+);
 export class FileNodeContentEntity extends TenantBaseEntity {
-    node;
-    size;
-    content;
-    mimeType;
-    md5;
-    sha256;
-    text;
-    width;
-    height;
-    // @Property({ type: types.integer, nullable: true })
-    // length?: number;
-    metadata;
+	node;
+	size;
+	content;
+	mimeType;
+	md5;
+	sha256;
+	text;
+	width;
+	height;
+	// @Property({ type: types.integer, nullable: true })
+	// length?: number;
+	metadata;
 }
-_ts_decorate([
-    OneToOne({
-        entity: () => FileNodeMetaEntity,
-        owner: true,
-        joinColumn: "node_id"
-    }),
-    _ts_metadata("design:type", typeof Rel === "undefined" ? Object : Rel)
-], FileNodeContentEntity.prototype, "node", void 0);
-_ts_decorate([
-    Property({
-        type: types.integer,
-        nullable: false
-    }),
-    _ts_metadata("design:type", Number)
-], FileNodeContentEntity.prototype, "size", void 0);
-_ts_decorate([
-    Property({
-        type: types.blob,
-        lazy: true,
-        comment: "\u6587\u4EF6\u5185\u5BB9"
-    }),
-    _ts_metadata("design:type", typeof Buffer === "undefined" ? Object : Buffer)
-], FileNodeContentEntity.prototype, "content", void 0);
-_ts_decorate([
-    Property({
-        type: types.string,
-        nullable: true
-    }),
-    _ts_metadata("design:type", String)
-], FileNodeContentEntity.prototype, "mimeType", void 0);
-_ts_decorate([
-    Property({
-        type: types.string,
-        nullable: false
-    }),
-    _ts_metadata("design:type", String)
-], FileNodeContentEntity.prototype, "md5", void 0);
-_ts_decorate([
-    Property({
-        type: types.string,
-        nullable: false
-    }),
-    _ts_metadata("design:type", String)
-], FileNodeContentEntity.prototype, "sha256", void 0);
-_ts_decorate([
-    Property({
-        type: types.string,
-        nullable: true
-    }),
-    _ts_metadata("design:type", String)
-], FileNodeContentEntity.prototype, "text", void 0);
-_ts_decorate([
-    Property({
-        type: types.integer,
-        nullable: true
-    }),
-    _ts_metadata("design:type", Number)
-], FileNodeContentEntity.prototype, "width", void 0);
-_ts_decorate([
-    Property({
-        type: types.integer,
-        nullable: true
-    }),
-    _ts_metadata("design:type", Number)
-], FileNodeContentEntity.prototype, "height", void 0);
-_ts_decorate([
-    Property({
-        type: types.json,
-        nullable: false,
-        defaultRaw: "{}"
-    }),
-    _ts_metadata("design:type", typeof Record === "undefined" ? Object : Record)
-], FileNodeContentEntity.prototype, "metadata", void 0);
-FileNodeContentEntity = _ts_decorate([
-    Entity({
-        tableName: "file_node_content"
-    })
-], FileNodeContentEntity);
+_ts_decorate(
+	[
+		OneToOne({
+			entity: () => FileNodeMetaEntity,
+			owner: true,
+			joinColumn: 'node_id',
+		}),
+		_ts_metadata('design:type', typeof Rel === 'undefined' ? Object : Rel),
+	],
+	FileNodeContentEntity.prototype,
+	'node',
+	void 0,
+);
+_ts_decorate(
+	[
+		Property({
+			type: types.integer,
+			nullable: false,
+		}),
+		_ts_metadata('design:type', Number),
+	],
+	FileNodeContentEntity.prototype,
+	'size',
+	void 0,
+);
+_ts_decorate(
+	[
+		Property({
+			type: types.blob,
+			lazy: true,
+			comment: '\u6587\u4EF6\u5185\u5BB9',
+		}),
+		_ts_metadata('design:type', typeof Buffer === 'undefined' ? Object : Buffer),
+	],
+	FileNodeContentEntity.prototype,
+	'content',
+	void 0,
+);
+_ts_decorate(
+	[
+		Property({
+			type: types.string,
+			nullable: true,
+		}),
+		_ts_metadata('design:type', String),
+	],
+	FileNodeContentEntity.prototype,
+	'mimeType',
+	void 0,
+);
+_ts_decorate(
+	[
+		Property({
+			type: types.string,
+			nullable: false,
+		}),
+		_ts_metadata('design:type', String),
+	],
+	FileNodeContentEntity.prototype,
+	'md5',
+	void 0,
+);
+_ts_decorate(
+	[
+		Property({
+			type: types.string,
+			nullable: false,
+		}),
+		_ts_metadata('design:type', String),
+	],
+	FileNodeContentEntity.prototype,
+	'sha256',
+	void 0,
+);
+_ts_decorate(
+	[
+		Property({
+			type: types.string,
+			nullable: true,
+		}),
+		_ts_metadata('design:type', String),
+	],
+	FileNodeContentEntity.prototype,
+	'text',
+	void 0,
+);
+_ts_decorate(
+	[
+		Property({
+			type: types.integer,
+			nullable: true,
+		}),
+		_ts_metadata('design:type', Number),
+	],
+	FileNodeContentEntity.prototype,
+	'width',
+	void 0,
+);
+_ts_decorate(
+	[
+		Property({
+			type: types.integer,
+			nullable: true,
+		}),
+		_ts_metadata('design:type', Number),
+	],
+	FileNodeContentEntity.prototype,
+	'height',
+	void 0,
+);
+_ts_decorate(
+	[
+		Property({
+			type: types.json,
+			nullable: false,
+			defaultRaw: '{}',
+		}),
+		_ts_metadata('design:type', typeof Record === 'undefined' ? Object : Record),
+	],
+	FileNodeContentEntity.prototype,
+	'metadata',
+	void 0,
+);
+FileNodeContentEntity = _ts_decorate(
+	[
+		Entity({
+			tableName: 'file_node_content',
+		}),
+	],
+	FileNodeContentEntity,
+);
 //# sourceMappingURL=createDatabaseFileSystem.js.map