@wener/common 2.0.1 → 2.0.3

package/lib/fs/server/createDatabaseFileSystem.js

@@ -0,0 +1,750 @@
+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";
+export function createDatabaseFileSystem(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);
+            }
+        }
+    }
+};
+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;
+    }
+}
+_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;
+}
+_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