@fiduswriter/document 0.1.0-alpha.4 → 0.1.0-alpha.5

package/src/importer/native/file.ts

@@ -0,0 +1,282 @@
+import {escapeText, gettext} from "fwtoolkit"
+
+import {FW_DOCUMENT_VERSION} from "../../schema/index.js"
+import {updateFile} from "./update.js"
+import {updateTemplateFile} from "./update_template.js"
+import {NativeImporter} from "./importer.js"
+
+import type {
+    E2EEOptions,
+    FidusDoc,
+    FidusNode,
+    ImageDBEntries,
+    NativeImporterBackend,
+    Template,
+    User
+} from "../../types.js"
+
+export const MIN_FW_DOCUMENT_VERSION = 1.6
+export const MAX_FW_DOCUMENT_VERSION = Number.parseFloat(FW_DOCUMENT_VERSION)
+
+const TEXT_FILENAMES = [
+    "mimetype",
+    "filetype-version",
+    "document.json",
+    "images.json",
+    "bibliography.json"
+]
+
+export interface FidusFileImporterOptions {
+    check?: boolean
+    contacts?: Array<Record<string, unknown>>
+    e2eeOptions?: E2EEOptions | null
+    checkDocUsers?: (
+        doc: Record<string, unknown>,
+        user: User,
+        contacts: Array<Record<string, unknown>>
+    ) => Record<string, unknown>
+}
+
+export class FidusFileImporter {
+    file: Blob
+    user: User
+    path: string
+    check: boolean
+    contacts: Array<Record<string, unknown>>
+    e2eeOptions: E2EEOptions | null
+    checkDocUsers?: (
+        doc: Record<string, unknown>,
+        user: User,
+        contacts: Array<Record<string, unknown>>
+    ) => Record<string, unknown>
+
+    textFiles: Array<{filename: string; content: string}> = []
+    otherFiles: Array<{filename: string; content: Blob | ArrayBuffer | string}> = []
+    ok = false
+    statusText = ""
+    doc: Record<string, unknown> | null = null
+    docInfo: Record<string, unknown> | null = null
+    template: Template | null = null
+
+    backend: NativeImporterBackend
+
+    constructor(
+        file: Blob,
+        user: User,
+        path: string,
+        backend: NativeImporterBackend,
+        options: FidusFileImporterOptions = {}
+    ) {
+        this.file = file
+        this.user = user
+        this.path = path
+        this.check = options.check ?? false
+        this.contacts = options.contacts || []
+        this.e2eeOptions = options.e2eeOptions ?? null
+        this.checkDocUsers = options.checkDocUsers
+        this.backend = backend
+    }
+
+    init(): Promise<this> {
+        if (!this.check) {
+            return this.initZipFileRead()
+        }
+        return new Promise(resolve => {
+            const reader = new FileReader()
+            reader.onloadend = () => {
+                const result = reader.result as string
+                if (
+                    result.length > 60 &&
+                    result.substring(0, 2) === "PK"
+                ) {
+                    this.initZipFileRead().then(() => resolve(this))
+                } else {
+                    this.statusText = gettext(
+                        "The uploaded file does not appear to be a Fidus Writer file."
+                    )
+                    resolve(this)
+                }
+            }
+            reader.readAsText(this.file)
+        })
+    }
+
+    initZipFileRead(): Promise<this> {
+        return import("jszip")
+            .then(({default: JSZip}) => new JSZip())
+            .then(zipfs => zipfs.loadAsync(this.file))
+            .then(zipfs => {
+                const filenames: string[] = []
+                const p: Array<Promise<void>> = []
+                let validFile = true
+
+                zipfs.forEach(filename => filenames.push(filename))
+
+                TEXT_FILENAMES.forEach(filename => {
+                    if (filenames.indexOf(filename) === -1) {
+                        validFile = false
+                    }
+                })
+                if (!validFile) {
+                    this.statusText = gettext(
+                        "The uploaded file does not appear to be a Fidus Writer file."
+                    )
+                    return this
+                }
+
+                filenames
+                    .filter(filename => !filename.endsWith("/"))
+                    .forEach(filename => {
+                        p.push(
+                            new Promise(resolve => {
+                                const isText =
+                                    ["mimetype", "filetype-version"].includes(
+                                        filename
+                                    ) || filename.endsWith(".json")
+                                zipfs.files[filename]
+                                    .async(isText ? "string" : "blob")
+                                    .then(content => {
+                                        if (isText) {
+                                            this.textFiles.push({
+                                                filename,
+                                                content: content as string
+                                            })
+                                        } else {
+                                            this.otherFiles.push({
+                                                filename,
+                                                content: content as Blob
+                                            })
+                                        }
+                                        resolve()
+                                    })
+                            })
+                        )
+                    })
+                return Promise.all(p).then(() => this.processFidusFile())
+            })
+    }
+
+    processFidusFile(): Promise<this> {
+        const filetypeVersionFile = this.textFiles.find(
+                file => file.filename === "filetype-version"
+            ),
+            mimeTypeFile = this.textFiles.find(
+                file => file.filename === "mimetype"
+            )
+
+        if (!filetypeVersionFile || !mimeTypeFile) {
+            this.statusText = gettext(
+                "The uploaded file does not appear to be a Fidus Writer file."
+            )
+            return Promise.resolve(this)
+        }
+
+        const filetypeVersion = Number.parseFloat(filetypeVersionFile.content),
+            mimeType = mimeTypeFile.content
+
+        if (
+            mimeType === "application/fidus+zip" &&
+            filetypeVersion >= MIN_FW_DOCUMENT_VERSION &&
+            filetypeVersion <= MAX_FW_DOCUMENT_VERSION
+        ) {
+            const documentFile = this.textFiles.find(
+                    file => file.filename === "document.json"
+                ),
+                bibliographyFile = this.textFiles.find(
+                    file => file.filename === "bibliography.json"
+                ),
+                imagesFile = this.textFiles.find(
+                    file => file.filename === "images.json"
+                )
+
+            if (!documentFile || !bibliographyFile || !imagesFile) {
+                this.statusText = gettext(
+                    "The uploaded file does not appear to be a Fidus Writer file."
+                )
+                return Promise.resolve(this)
+            }
+
+            const updatedFile = updateFile(
+                    JSON.parse(documentFile.content) as FidusDoc,
+                    filetypeVersion,
+                    JSON.parse(bibliographyFile.content),
+                    JSON.parse(imagesFile.content) as ImageDBEntries
+                ),
+                bibliography = updatedFile.bibliography,
+                images = updatedFile.images
+            let doc = updatedFile.doc as unknown as Record<string, unknown>
+            if (this.check && this.checkDocUsers) {
+                doc = this.checkDocUsers(doc, this.user, this.contacts)
+            }
+
+            const templateFiles = this.otherFiles.filter(
+                file =>
+                    file.filename.startsWith("exporttemplates/") ||
+                    file.filename.startsWith("documentstyles/")
+            )
+            this.otherFiles = this.otherFiles.filter(
+                file =>
+                    !file.filename.startsWith("exporttemplates/") &&
+                    !file.filename.startsWith("documentstyles/")
+            )
+
+            const templateFile = this.textFiles.find(
+                file => file.filename === "template.json"
+            )
+            if (templateFile) {
+                const exporttemplatesFile = this.textFiles.find(
+                        file => file.filename === "exporttemplates.json"
+                    ),
+                    documentstylesFile = this.textFiles.find(
+                        file => file.filename === "documentstyles.json"
+                    )
+                if (!exporttemplatesFile || !documentstylesFile) {
+                    this.statusText = gettext(
+                        "The uploaded file does not appear to be a Fidus Writer file."
+                    )
+                    return Promise.resolve(this)
+                }
+                const templateDef = JSON.parse(templateFile.content)
+                this.template = updateTemplateFile(
+                    templateDef.attrs.template,
+                    templateDef,
+                    JSON.parse(exporttemplatesFile.content),
+                    JSON.parse(documentstylesFile.content),
+                    filetypeVersion
+                ) as Template
+                this.template.files = templateFiles
+            }
+
+            const importer = new NativeImporter(
+                doc,
+                bibliography,
+                {db: images},
+                this.otherFiles,
+                this.user,
+                this.backend,
+                {
+                    importId: null,
+                    requestedPath: this.path.endsWith("/")
+                        ? this.path + (doc.title as string)
+                        : this.path,
+                    template: this.template,
+                    e2eeOptions: this.e2eeOptions
+                }
+            )
+            return importer.init().then(({doc: importedDoc, docInfo}) => {
+                this.ok = true
+                this.doc = importedDoc
+                this.docInfo = docInfo
+                this.statusText = `${escapeText(
+                    importedDoc.title as string
+                )} ${gettext("successfully imported.")}`
+                return this
+            })
+        }
+        this.statusText =
+            gettext(
+                "The uploaded file does not appear to be of the version used on this server: "
+            ) + FW_DOCUMENT_VERSION
+        return Promise.resolve(this)
+    }
+}

package/src/importer/native/get_images.ts

@@ -0,0 +1,82 @@
+import {get} from "fwtoolkit"
+
+import type {ImageDB, ImageDBEntry} from "../../types.js"
+
+interface ZipEntry {
+    filename: string
+    content: Blob | ArrayBuffer | string
+}
+
+interface UrlEntry {
+    filename: string
+    url: string
+}
+
+export class GetImages {
+    images: ImageDB
+    imageEntries: ImageDBEntry[]
+    entries: Array<ZipEntry | UrlEntry>
+    counter: number
+
+    constructor(images: ImageDB, entries: Array<ZipEntry | UrlEntry>) {
+        this.images = images
+        this.imageEntries = Object.values(this.images.db)
+        this.entries = entries
+        this.counter = 0
+    }
+
+    async init(): Promise<void> {
+        if (this.entries.length === 0) {
+            return
+        }
+        if (this.entries[0].hasOwnProperty("url")) {
+            await this.getImageUrlEntry()
+        } else {
+            await this.getImageZipEntry()
+        }
+    }
+
+    async getImageZipEntry(): Promise<void> {
+        if (this.counter >= this.imageEntries.length) {
+            return
+        }
+        const imageEntry = this.imageEntries[this.counter]
+        const f = (this.entries as ZipEntry[]).find(
+            e => e.filename === imageEntry.image
+        )
+        if (!f) {
+            console.warn(
+                `Image ${imageEntry.image} not found`,
+                this.imageEntries,
+                this.entries
+            )
+            this.counter++
+            await this.getImageZipEntry()
+            return
+        }
+        this.imageEntries[this.counter]["file"] = new window.Blob([f.content], {
+            type: imageEntry.file_type
+        })
+        this.counter++
+        await this.getImageZipEntry()
+    }
+
+    async getImageUrlEntry(): Promise<void> {
+        if (this.counter >= this.imageEntries.length) {
+            return
+        }
+        const imageEntry = this.imageEntries[this.counter]
+        const entry = (this.entries as UrlEntry[]).find(
+            e =>
+                e.filename ===
+                `images/${String(imageEntry.image).split("/").pop()}`
+        )
+        if (!entry) {
+            return
+        }
+        const response = await get(entry.url)
+        this.imageEntries[this.counter]["file"] = await response.blob()
+        this.counter++
+        await this.getImageUrlEntry()
+    }
+}

package/src/importer/native/importer.ts

@@ -0,0 +1,244 @@
+import {GetImages} from "./get_images.js"
+import {extractTemplate} from "./extract_template.js"
+
+import type {
+    BibDB,
+    E2EEOptions,
+    FidusNode,
+    ImageDB,
+    NativeImporterBackend,
+    Template,
+    User
+} from "../../types.js"
+
+interface NativeImporterOptions {
+    importId?: string | number | null
+    requestedPath?: string
+    template?: Template | null
+    e2eeOptions?: E2EEOptions | null
+}
+
+interface SaveDocumentResult {
+    added: number
+    updated: number
+}
+
+export class NativeImporter {
+    doc: Record<string, unknown>
+    docId: number
+    path: string
+    bibliography: Record<string, unknown>
+    images: ImageDB
+    otherFiles: Array<{filename: string; content: Blob | ArrayBuffer | string}>
+    user: User
+    importId: string | number | null
+    requestedPath: string
+    template: Template | null
+    e2eeOptions: E2EEOptions | null
+    backend: NativeImporterBackend
+
+    constructor(
+        doc: Record<string, unknown>,
+        bibliography: Record<string, unknown>,
+        images: ImageDB,
+        otherFiles: Array<{filename: string; content: Blob | ArrayBuffer | string}>,
+        user: User,
+        backend: NativeImporterBackend,
+        options: NativeImporterOptions = {}
+    ) {
+        this.doc = doc
+        this.docId = 0
+        this.path = ""
+        this.bibliography = bibliography
+        this.images = images
+        this.otherFiles = otherFiles
+        this.user = user
+        this.importId = options.importId ?? null
+        this.requestedPath = options.requestedPath || ""
+        this.template = options.template ?? null
+        this.e2eeOptions = options.e2eeOptions ?? null
+        this.backend = backend
+    }
+
+    init(): Promise<{doc: Record<string, unknown>; docInfo: Record<string, unknown>}> {
+        const imageGetter = new GetImages(this.images, this.otherFiles)
+        return imageGetter
+            .init()
+            .then(() => {
+                const missingImage = Object.values(this.images.db).find(
+                    imageEntry => !imageEntry.file
+                )
+                if (missingImage) {
+                    throw new Error(
+                        `Could not create document. Missing image file: ${String(
+                            missingImage.image
+                        )}`
+                    )
+                }
+            })
+            .then(() => this.createDoc())
+            .then(() => {
+                if (!this.docId) {
+                    return Promise.reject(new Error("document not created"))
+                }
+                return this.saveImages()
+            })
+            .then((imageTranslationTable: Record<number | string, number>) => {
+                this.translateReferenceIds(imageTranslationTable)
+                return this.saveDocument()
+            })
+    }
+
+    createDoc(): Promise<void> {
+        const template = this.template
+            ? this.template
+            : (this.backend.extractTemplate || extractTemplate)(
+                  this.doc.content as FidusNode
+              )
+
+        const jsonData: Record<string, unknown> = {
+            template: template.content,
+            export_templates: template.exportTemplates,
+            document_styles: template.documentStyles,
+            import_id: this.importId
+                ? this.importId
+                : (template.content.attrs as Record<string, unknown>)?.import_id,
+            template_title: (template.content.attrs as Record<string, unknown>)
+                ?.template,
+            path: this.requestedPath
+        }
+
+        if (this.e2eeOptions?.enabled) {
+            jsonData.e2ee = true
+            if (this.e2eeOptions.salt) {
+                jsonData.e2ee_salt = this.e2eeOptions.salt
+            }
+            if (this.e2eeOptions.iterations) {
+                jsonData.e2ee_iterations = this.e2eeOptions.iterations
+            }
+        }
+
+        const files: Record<string, File[]> = {}
+        if (template.files?.length) {
+            files.files = template.files.map(
+                ({filename, content}) => new File([content as BlobPart], filename)
+            )
+        }
+
+        return this.backend
+            .createDoc(
+                template,
+                this.importId,
+                this.requestedPath,
+                this.e2eeOptions,
+                files
+            )
+            .then(({id, path, e2ee}) => {
+                this.docId = id
+                this.path = path
+                this.doc.e2ee = e2ee || false
+            })
+    }
+
+    saveImages(): Promise<Record<number | string, number>> {
+        return this.backend.saveImages(
+            this.images,
+            this.docId,
+            this.e2eeOptions
+        )
+    }
+
+    translateReferenceIds(imageTranslationTable: Record<number | string, number>): void {
+        const walkTree = (node: FidusNode): void => {
+            switch (node.type) {
+                case "image":
+                    if (node.attrs && node.attrs.image !== false) {
+                        node.attrs.image =
+                            imageTranslationTable[node.attrs.image as number | string]
+                    }
+                    break
+                case "footnote":
+                    if (node.attrs?.footnote) {
+                        ;(node.attrs.footnote as FidusNode[]).forEach(childNode =>
+                            walkTree(childNode)
+                        )
+                    }
+                    break
+            }
+            if (node.content) {
+                node.content.forEach(childNode => walkTree(childNode))
+            }
+        }
+        walkTree(this.doc.content as FidusNode)
+    }
+
+    async saveDocument(): Promise<{doc: Record<string, unknown>; docInfo: Record<string, unknown>}> {
+        let saveData: Record<string, unknown>
+        if (this.e2eeOptions?.enabled && this.e2eeOptions.key) {
+            const encryptedContent = await this.backend.encryptObject!(
+                this.doc.content,
+                this.e2eeOptions.key
+            )
+            const encryptedComments = await this.backend.encryptObject!(
+                this.doc.comments || {},
+                this.e2eeOptions.key
+            )
+            const encryptedBibliography = await this.backend.encryptObject!(
+                this.bibliography,
+                this.e2eeOptions.key
+            )
+            const encryptedTitle = await this.backend.encrypt!(
+                this.doc.title as string,
+                this.e2eeOptions.key
+            )
+            saveData = {
+                id: this.docId,
+                title: encryptedTitle,
+                content: encryptedContent,
+                comments: encryptedComments,
+                bibliography: encryptedBibliography
+            }
+        } else {
+            saveData = {
+                id: this.docId,
+                title: this.doc.title,
+                content: this.doc.content,
+                comments: this.doc.comments,
+                bibliography: this.bibliography
+            }
+        }
+        return this.backend
+            .saveDocument(saveData, this.e2eeOptions)
+            .then(({added, updated}: SaveDocumentResult) => {
+                const docInfo: Record<string, unknown> = {
+                    is_owner: true,
+                    access_rights: "write",
+                    id: this.docId
+                }
+                this.doc.owner = {
+                    id: this.user.id,
+                    name: this.user.name,
+                    avatar: this.user.avatar
+                }
+                this.doc.is_owner = true
+                this.doc.version = 0
+                this.doc.comment_version = 0
+                this.doc.id = this.docId
+                this.doc.added = added
+                this.doc.updated = updated
+                this.doc.revisions = []
+                this.doc.rights = "write"
+                this.doc.path = this.path
+                this.doc.e2ee = this.doc.e2ee || false
+                if (
+                    this.e2eeOptions?.enabled &&
+                    this.e2eeOptions.key &&
+                    this.docId &&
+                    this.backend.storeKeyInSession
+                ) {
+                    this.backend.storeKeyInSession(this.docId, this.e2eeOptions.key)
+                }
+                return {doc: this.doc, docInfo}
+            })
+    }
+}

package/src/importer/native/index.ts

@@ -0,0 +1,6 @@
+export {GetImages} from "./get_images.js"
+export {updateFile} from "./update.js"
+export {updateTemplateFile} from "./update_template.js"
+export {extractTemplate} from "./extract_template.js"
+export {NativeImporter} from "./importer.js"
+export {FidusFileImporter} from "./file.js"

package/src/importer/native/{update.js → update.ts}

@@ -1,6 +1,13 @@
 import {updateDoc} from "../../schema/convert.js"
 
-export function updateFile(doc, filetypeVersion, bibliography, images) {
+import type {FidusDoc, ImageDBEntries} from "../../types.js"
+
+export function updateFile(
+    doc: FidusDoc,
+    filetypeVersion: number,
+    bibliography: Record<string, unknown>,
+    images: ImageDBEntries
+): {doc: FidusDoc; bibliography: Record<string, unknown>; images: ImageDBEntries} {
     // update bibliography -- currently not needed
     // bibliography = updateBib(bibliography)
     if (filetypeVersion < 3.2) {
@@ -14,15 +21,16 @@ export function updateFile(doc, filetypeVersion, bibliography, images) {
                 })
         )
     }
+    const docRecord = doc as unknown as Record<string, unknown>
     if (filetypeVersion < 3.3) {
-        doc.content = doc.contents
-        delete doc.contents
+        docRecord.content = docRecord.contents
+        delete docRecord.contents
     }
     if (filetypeVersion < 2.0) {
         // Before 2.0, version numbers of the doc and of the file differed.
-        doc = updateDoc(doc, doc.settings["doc_version"], bibliography)
+        doc = updateDoc(doc, (docRecord.settings as Record<string, unknown>)["doc_version"] as number, bibliography as any) as FidusDoc
     } else {
-        doc = updateDoc(doc, filetypeVersion, bibliography)
+        doc = updateDoc(doc, filetypeVersion, bibliography as any) as FidusDoc
     }
 
     return {doc, bibliography, images}

package/src/importer/native/update_template.ts

@@ -0,0 +1,32 @@
+import {updateDoc} from "../../schema/convert.js"
+
+import type {FidusNode, JSONValue} from "../../types.js"
+
+/**
+ * Update a template definition that has been read from a fidus/template file
+ * to the current document schema version.
+ */
+export function updateTemplateFile(
+    title: string,
+    content: FidusNode,
+    exportTemplates: Array<Record<string, JSONValue>>,
+    documentStyles: Array<Record<string, JSONValue>>,
+    filetypeVersion: number
+): {
+    title: string
+    content: FidusNode
+    exportTemplates: Array<Record<string, JSONValue>>
+    documentStyles: Array<Record<string, JSONValue>>
+} {
+    const oldDoc = {
+        content,
+        diffs: [],
+        bibliography: {},
+        comments: {},
+        title,
+        version: 1,
+        id: 1
+    }
+    const doc = updateDoc(oldDoc, filetypeVersion)
+    return {title, content: doc.content as FidusNode, exportTemplates, documentStyles}
+}