5htp-core 0.4.9-2 → 0.4.9-5

package/src/server/utils/slug.ts

@@ -0,0 +1,67 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import escapeStringRegexp from 'escape-regexp';
+import slugify from 'slugify';
+import { removeStopwords, eng } from 'stopword';
+
+// Core
+import type SQL from "@server/services/database";
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+/*----------------------------------
+- SERVICE
+----------------------------------*/
+export class Slug {
+
+    public async generate( label: string );
+    public async generate( label: string, SQL: SQL, table: string, column: string );
+    public async generate( label: string, SQL?: SQL, table?: string, column?: string ) {
+
+        // Generate slug
+        let slug = slugify(label, {
+            replacement: '-',  // replace spaces with replacement character, defaults to `-`
+            remove: undefined, // remove characters that match regex, defaults to `undefined`
+            lower: true,      // convert to lower case, defaults to `false`
+            strict: false,     // strip special characters except replacement, defaults to `false`
+            locale: 'vi',       // language code of the locale to use
+            trim: true         // trim leading and trailing replacement chars, defaults to `true`
+        });
+
+        slug = removeStopwords( slug.split('-'), eng).join('-');
+
+        // Check if already existing
+        if (SQL !== undefined) {
+
+            const escapedSlug = escapeStringRegexp(slug);
+
+            const duplicates = await SQL.selectVal<number>(`
+                SELECT 
+                    IF( ${column} LIKE ${SQL.esc(slug)},
+                        1,
+                        CAST(SUBSTRING_INDEX(slug, '-', -1) AS UNSIGNED)
+                    ) AS duplicates
+                FROM ${table} 
+                WHERE 
+                    ${column} LIKE ${SQL.esc(slug)}
+                    OR
+                    ${column} REGEXP '^${escapedSlug}-[0-9]+$'
+                ORDER BY duplicates DESC
+                LIMIT 1
+            `);
+
+            if (duplicates && duplicates > 0)
+                slug += `-${duplicates + 1}`;
+        }
+
+        return slug;
+    }
+
+}
+
+export default new Slug;

package/src/server/services/schema/rte.ts

@@ -1,110 +0,0 @@
-/*----------------------------------
-- DEPENDANCES
-----------------------------------*/
-
-// Node
-import path from 'path';
-import md5 from 'md5';
-import { fromBuffer } from 'file-type';
-
-// Npm
-import type { SerializedEditorState, SerializedLexicalNode } from 'lexical';
-
-// Core
-import type Driver from '@server/services/disks/driver';
-
-type SerializedLexicalNodeWithSrc = SerializedLexicalNode & { src: string };
-
-/*----------------------------------
-- METHODS
-----------------------------------*/
-const uploadAttachments = async ( 
-    value: SerializedEditorState, 
-    disk: Driver, 
-    destination: string,
-    oldState?: SerializedEditorState
-) => {
-
-    const usedFilesUrl: string[] = [];
-
-    // Deep check for images / files
-    const findFiles = async (
-        node: SerializedLexicalNode,
-        callback: (node: SerializedLexicalNodeWithSrc) => Promise<void>
-    ) => {
-
-        // Attachment
-        if (node.type === 'image' || node.type === 'file') {
-            if (typeof node.src === 'string') {
-                await callback(node as SerializedLexicalNodeWithSrc);
-            }
-            // Recursion
-        } else if (node.children) {
-            for (const child of node.children) {
-                await findFiles(child, callback);
-            }
-        }
-    }
-
-    const uploadFile = async (node: SerializedLexicalNodeWithSrc) => {
-
-        // Already uploaded
-        if (!node.src.startsWith('data:')) {
-            usedFilesUrl.push(node.src);
-            return node.src;
-        }
-
-        // Transform into buffer
-        node.src = node.src.replace(/^data:\w+\/\w+;base64,/, '');
-        const fileData = Buffer.from(node.src, 'base64');
-
-        // Parse file type from buffer
-        const fileType = await fromBuffer(fileData);
-        if (!fileType)
-            throw new Error('Failed to detect file type');
-
-        // Upload file to disk
-        const fileName = md5(node.src) + '.' + fileType.ext;
-        const filePath = path.join(destination, fileName);
-        const upoadedFile = await disk.outputFile('data', filePath, fileData, {
-            encoding: 'binary'
-        });
-
-        // Replace node.src with url
-        node.src = upoadedFile.path;
-        usedFilesUrl.push(node.src);
-    }
-
-    const deleteUnusedFile = async (node: SerializedLexicalNodeWithSrc) => {
-
-        // Should be a URL
-        if (node.src.startsWith('data:') || !node.src.startsWith('http'))
-            return;
-
-        // This file is used
-        if (usedFilesUrl.includes(node.src))
-            return;
-
-        // Extract file name
-        const fileName = path.basename(node.src);
-        const filePath = path.join(destination, fileName);
-
-        // Delete file from disk
-        await disk.delete('data', filePath);
-        console.log('Deleted file:', filePath);
-    }
-
-    // Find files in the editor state
-    for (const child of value.root.children) {
-        await findFiles(child, uploadFile);
-    }
-
-    // Old state given: remove unused attachments
-    if (oldState !== undefined) {
-        for (const child of oldState.root.children) {
-            await findFiles(child, deleteUnusedFile);
-        }
-    }
-}
-
-export default { uploadAttachments }