@promptbook/cli 0.103.0-8 → 0.103.0

package/apps/agents-server/src/tools/$provideAgentCollectionForServer.ts

@@ -0,0 +1,54 @@
+'use server';
+
+import { AgentCollectionInSupabase } from '@promptbook-local/core';
+import { AgentCollection } from '@promptbook-local/types';
+import { just } from '../../../../src/utils/organization/just';
+import { $provideSupabaseForServer } from '../database/$provideSupabaseForServer';
+import { $provideServer } from './$provideServer';
+
+/**
+ * Cache of provided agent collection
+ *
+ * @private internal cache for `$provideAgentCollectionForServer`
+ */
+let agentCollection: null | AgentCollection = null;
+
+/**
+ * [🐱‍🚀]
+ */
+export async function $provideAgentCollectionForServer(): Promise<AgentCollection> {
+    // <- Note: This function is potentially async
+
+    // TODO: [🐱‍🚀] [🌕] DRY
+
+    const isVerbose = true; // <- TODO: [🐱‍🚀] Pass
+
+    if (agentCollection !== null && just(false /* <- TODO: [🐱‍🚀] Fix caching */)) {
+        console.log('[🐱‍🚀] Returning cached agent collection');
+        return agentCollection;
+        // TODO: [🐱‍🚀] Be aware of options changes
+    }
+
+    console.log('[🐱‍🚀] Creating NEW agent collection');
+
+    /*
+    // TODO: [🧟‍♂️][◽] DRY:
+    const collection = new AgentCollectionInDirectory(path, tools, {
+        isVerbose,
+        isRecursive: true,
+        isLazyLoaded: false,
+        isCrashedOnError: true,
+        // <- TODO: [🍖] Add `intermediateFilesStrategy`
+    });
+    */
+
+    const supabase = $provideSupabaseForServer();
+    const { tablePrefix } = await $provideServer();
+
+    agentCollection = new AgentCollectionInSupabase(supabase, {
+        isVerbose,
+        tablePrefix,
+    });
+
+    return agentCollection;
+}

package/apps/agents-server/src/tools/$provideCdnForServer.ts

@@ -0,0 +1,36 @@
+import { VercelBlobStorage } from '../utils/cdn/classes/VercelBlobStorage';
+import { IIFilesStorageWithCdn } from '../utils/cdn/interfaces/IFilesStorage';
+
+/**
+ * Cache of CDN instance
+ *
+ * @private internal cache for `$provideCdnForServer`
+ */
+let cdn: IIFilesStorageWithCdn | null = null;
+
+/**
+ * [🐱‍🚀]
+ */
+export function $provideCdnForServer(): IIFilesStorageWithCdn {
+    if (!cdn) {
+        cdn = new VercelBlobStorage({
+            token: process.env.VERCEL_BLOB_READ_WRITE_TOKEN!,
+            pathPrefix: process.env.NEXT_PUBLIC_CDN_PATH_PREFIX!,
+            cdnPublicUrl: new URL(process.env.NEXT_PUBLIC_CDN_PUBLIC_URL!),
+        });
+
+        /*
+        cdn = new DigitalOceanSpaces({
+            bucket: process.env.CDN_BUCKET!,
+            pathPrefix: process.env.NEXT_PUBLIC_CDN_PATH_PREFIX!,
+            endpoint: process.env.CDN_ENDPOINT!,
+            accessKeyId: process.env.CDN_ACCESS_KEY_ID!,
+            secretAccessKey: process.env.CDN_SECRET_ACCESS_KEY!,
+            cdnPublicUrl: new URL(process.env.NEXT_PUBLIC_CDN_PUBLIC_URL!),
+            gzip: true,
+        });
+        */
+    }
+
+    return cdn;
+}

package/apps/agents-server/src/tools/$provideExecutionToolsForServer.ts

@@ -0,0 +1,117 @@
+'use server';
+
+import {
+    cacheLlmTools,
+    _AnthropicClaudeMetadataRegistration,
+    _AzureOpenAiMetadataRegistration,
+    _BoilerplateScraperMetadataRegistration,
+    _DeepseekMetadataRegistration,
+    _DocumentScraperMetadataRegistration,
+    _GoogleMetadataRegistration,
+    _LegacyDocumentScraperMetadataRegistration,
+    _MarkdownScraperMetadataRegistration,
+    _MarkitdownScraperMetadataRegistration,
+    _OllamaMetadataRegistration,
+    _OpenAiAssistantMetadataRegistration,
+    _OpenAiCompatibleMetadataRegistration,
+    _OpenAiMetadataRegistration,
+    _PdfScraperMetadataRegistration,
+    _WebsiteScraperMetadataRegistration,
+} from '@promptbook-local/core';
+import { _GoogleRegistration } from '@promptbook-local/google';
+import { _OpenAiRegistration } from '@promptbook-local/openai';
+import { ExecutionTools, TODO_any } from '@promptbook-local/types';
+import { $provideLlmToolsForCli } from '../../../../src/cli/common/$provideLlmToolsForCli';
+import { $provideExecutablesForNode } from '../../../../src/executables/$provideExecutablesForNode';
+import { $provideFilesystemForNode } from '../../../../src/scrapers/_common/register/$provideFilesystemForNode';
+import { $provideScrapersForNode } from '../../../../src/scrapers/_common/register/$provideScrapersForNode';
+import { $provideScriptingForNode } from '../../../../src/scrapers/_common/register/$provideScriptingForNode';
+import { $sideEffect } from '../../../../src/utils/organization/$sideEffect';
+import { SupabaseCacheStorage } from '../utils/cache/SupabaseCacheStorage';
+
+$sideEffect(
+    _AnthropicClaudeMetadataRegistration,
+    _AzureOpenAiMetadataRegistration,
+    _DeepseekMetadataRegistration,
+    _GoogleMetadataRegistration,
+    _OllamaMetadataRegistration,
+    _OpenAiMetadataRegistration,
+    _OpenAiAssistantMetadataRegistration,
+    _OpenAiCompatibleMetadataRegistration,
+    _BoilerplateScraperMetadataRegistration,
+    _LegacyDocumentScraperMetadataRegistration,
+    _DocumentScraperMetadataRegistration,
+    _MarkdownScraperMetadataRegistration,
+    _MarkitdownScraperMetadataRegistration,
+    _PdfScraperMetadataRegistration,
+    _WebsiteScraperMetadataRegistration,
+    // <- TODO: [🐱‍🚀] Export all registrations from one variabile in `@promptbook/core`
+);
+$sideEffect(/* [㊗] */ _OpenAiRegistration);
+$sideEffect(/* [㊗] */ _GoogleRegistration);
+// <- TODO: [🐱‍🚀] Allow to dynamically install required metadata
+
+/**
+ * Cache of provided execution tools
+ *
+ * @private internal cache for `$provideExecutionToolsForServer`
+ */
+let executionTools: null | ExecutionTools = null;
+
+/*
+TODO: [▶️]
+type ProvideExecutionToolsForServerOptions = {
+ isLlmProvided
+}
+*/
+
+/**
+ * [🐱‍🚀]
+ */
+export async function $provideExecutionToolsForServer(): Promise<ExecutionTools> {
+    // TODO: [🐱‍🚀] [🌕] DRY
+
+    // const path = '../../agents'; // <- TODO: [🐱‍🚀] Pass
+    const isVerbose = true; // <- TODO: [🐱‍🚀] Pass
+    const isCacheReloaded = false; // <- TODO: [🐱‍🚀] Pass
+    const cliOptions = {
+        provider: 'BRING_YOUR_OWN_KEYS',
+    } as TODO_any; // <- TODO: [🐱‍🚀] Pass
+
+    if (executionTools !== null) {
+        console.log('[🐱‍🚀] Returning cached execution tools');
+        return executionTools;
+        // TODO: [🐱‍🚀] Be aware of options changes
+    }
+
+    console.log('[🐱‍🚀] Creating NEW execution tools');
+
+    // TODO: DRY [◽]
+    const prepareAndScrapeOptions = {
+        isVerbose,
+        isCacheReloaded,
+    }; /* <- TODO: ` satisfies PrepareAndScrapeOptions` */
+    const fs = await $provideFilesystemForNode(prepareAndScrapeOptions);
+    const { /* [0] strategy,*/ llm: llmUncached } = await $provideLlmToolsForCli({
+        cliOptions,
+        ...prepareAndScrapeOptions,
+    });
+
+    const llm = cacheLlmTools(llmUncached, {
+        storage: new SupabaseCacheStorage(),
+        isVerbose,
+        isCacheReloaded,
+    });
+
+    const executables = await $provideExecutablesForNode(prepareAndScrapeOptions);
+
+    executionTools = {
+        llm,
+        fs,
+        executables,
+        scrapers: await $provideScrapersForNode({ fs, llm, executables }, prepareAndScrapeOptions),
+        script: await $provideScriptingForNode(prepareAndScrapeOptions),
+    };
+
+    return executionTools;
+}

package/apps/agents-server/src/tools/$provideOpenAiAssistantExecutionToolsForServer.ts

@@ -0,0 +1,35 @@
+'use server';
+
+import { OpenAiAssistantExecutionTools } from '@promptbook-local/openai';
+
+/**
+ * Cache of provided OpenAiAssistantExecutionTools
+ *
+ * @private internal cache for `$provideOpenAiAssistantExecutionToolsForServer`
+ */
+let executionTools: null | OpenAiAssistantExecutionTools = null;
+
+/**
+ * [🐱‍🚀]
+ */
+export async function $provideOpenAiAssistantExecutionToolsForServer(): Promise<OpenAiAssistantExecutionTools> {
+    // TODO: [🐱‍🚀] [🌕] DRY
+    const isVerbose = true; // <- TODO: [🐱‍🚀] Pass
+
+    if (executionTools !== null) {
+        console.log('[🐱‍🚀] Returning cached OpenAiAssistantExecutionTools');
+        return executionTools;
+        // TODO: [🐱‍🚀] Be aware of options changes
+    }
+
+    console.log('[🐱‍🚀] Creating NEW OpenAiAssistantExecutionTools');
+
+    executionTools = new OpenAiAssistantExecutionTools({
+        apiKey: process.env.OPENAI_API_KEY,
+        assistantId: 'abstract_assistant', // <- TODO: [🐱‍🚀] In `OpenAiAssistantExecutionTools` Allow to create abstract assistants with `isCreatingNewAssistantsAllowed`
+        isCreatingNewAssistantsAllowed: true,
+        isVerbose,
+    });
+
+    return executionTools;
+}

package/apps/agents-server/src/tools/$provideServer.ts

@@ -0,0 +1,39 @@
+import { NEXT_PUBLIC_SITE_URL, SERVERS, SUPABASE_TABLE_PREFIX } from '@/config';
+import { normalizeTo_PascalCase } from '@promptbook-local/utils';
+import { headers } from 'next/headers';
+
+export async function $provideServer() {
+    if (!SERVERS) {
+        return {
+            publicUrl: NEXT_PUBLIC_SITE_URL || new URL(`https://${(await headers()).get('host') || 'localhost:4440'}`),
+            tablePrefix: SUPABASE_TABLE_PREFIX,
+        };
+    }
+
+    const headersList = await headers();
+    let host = headersList.get('host');
+    const xPromptbookServer = headersList.get('x-promptbook-server');
+
+    if (host === null) {
+        throw new Error('Host header is missing');
+    }
+
+    // If host is not in known servers, check if we have a context header from middleware
+    if (!SERVERS.some((server) => server === host)) {
+        if (xPromptbookServer && SERVERS.some((server) => server === xPromptbookServer)) {
+            host = xPromptbookServer;
+        } else {
+            throw new Error(`Server with host "${host}" is not configured in SERVERS`);
+        }
+    }
+
+    let serverName = host;
+
+    serverName = serverName.replace(/\.ptbk\.io$/, '');
+    serverName = normalizeTo_PascalCase(serverName);
+
+    return {
+        publicUrl: new URL(`https://${host}`),
+        tablePrefix: `server_${serverName}_`,
+    };
+}

package/apps/agents-server/src/utils/auth.ts

@@ -0,0 +1,33 @@
+import { randomBytes, scrypt, timingSafeEqual } from 'crypto';
+import { promisify } from 'util';
+
+const scryptAsync = promisify(scrypt);
+
+/**
+ * Hashes a password using scrypt
+ * 
+ * @param password The plain text password
+ * @returns The salt and hash formatted as "salt:hash"
+ */
+export async function hashPassword(password: string): Promise<string> {
+    const salt = randomBytes(16).toString('hex');
+    const derivedKey = (await scryptAsync(password, salt, 64)) as Buffer;
+    return `${salt}:${derivedKey.toString('hex')}`;
+}
+
+/**
+ * Verifies a password against a stored hash
+ * 
+ * @param password The plain text password
+ * @param storedHash The stored hash in format "salt:hash"
+ * @returns True if the password matches
+ */
+export async function verifyPassword(password: string, storedHash: string): Promise<boolean> {
+    const [salt, key] = storedHash.split(':');
+    if (!salt || !key) return false;
+    
+    const derivedKey = (await scryptAsync(password, salt, 64)) as Buffer;
+    const keyBuffer = Buffer.from(key, 'hex');
+    
+    return timingSafeEqual(derivedKey, keyBuffer);
+}

package/apps/agents-server/src/utils/authenticateUser.ts

@@ -0,0 +1,42 @@
+import { $getTableName } from '../database/$getTableName';
+import { $provideSupabaseForServer } from '../database/$provideSupabaseForServer';
+import { AgentsServerDatabase } from '../database/schema';
+import { verifyPassword } from './auth';
+
+export type AuthenticatedUser = {
+    username: string;
+    isAdmin: boolean;
+};
+
+export async function authenticateUser(username: string, password: string): Promise<AuthenticatedUser | null> {
+    // 1. Check if it's the environment admin
+    if (username === 'admin' && process.env.ADMIN_PASSWORD && password === process.env.ADMIN_PASSWORD) {
+        return { username: 'admin', isAdmin: true };
+    }
+
+    // 2. Check DB users
+    try {
+        const supabase = $provideSupabaseForServer();
+        const { data: user, error } = await supabase
+            .from(await $getTableName('User'))
+            .select('*')
+            .eq('username', username)
+            .single();
+
+        if (error || !user) {
+            return null;
+        }
+
+        const userRow = user as AgentsServerDatabase['public']['Tables']['User']['Row'];
+        const isValid = await verifyPassword(password, userRow.passwordHash);
+
+        if (!isValid) {
+            return null;
+        }
+
+        return { username: userRow.username, isAdmin: userRow.isAdmin };
+    } catch (error) {
+        console.error('Authentication error:', error);
+        return null;
+    }
+}

package/apps/agents-server/src/utils/cache/SupabaseCacheStorage.ts

@@ -0,0 +1,55 @@
+import { TODO_any } from '@promptbook-local/types';
+import { $getTableName } from '../../database/$getTableName';
+import { $provideSupabaseForServer } from '../../database/$provideSupabaseForServer';
+import { Json } from '../../database/schema';
+
+/**
+ * Storage for LLM cache using Supabase
+ */
+export class SupabaseCacheStorage {
+    // implements PromptbookStorage<TODO_any>
+
+    /**
+     * Returns the current value associated with the given key, or null if the given key does not exist in the list associated with the object.
+     */
+    public async getItem(key: string): Promise<TODO_any | null> {
+        const supabase = $provideSupabaseForServer();
+        const tableName = await $getTableName('LlmCache');
+
+        const { data } = await supabase.from(tableName).select('value').eq('hash', key).maybeSingle();
+
+        if (!data) {
+            return null;
+        }
+
+        return data.value;
+    }
+
+    /**
+     * Sets the value of the pair identified by key to value, creating a new key/value pair if none existed for key previously.
+     */
+    public async setItem(key: string, value: TODO_any): Promise<void> {
+        const supabase = $provideSupabaseForServer();
+        const tableName = await $getTableName('LlmCache');
+
+        await supabase.from(tableName).upsert(
+            {
+                hash: key,
+                value: value as Json,
+            },
+            {
+                onConflict: 'hash',
+            },
+        );
+    }
+
+    /**
+     * Removes the key/value pair with the given key from the list associated with the object, if a key/value pair with the given key exists
+     */
+    public async removeItem(key: string): Promise<void> {
+        const supabase = $provideSupabaseForServer();
+        const tableName = await $getTableName('LlmCache');
+
+        await supabase.from(tableName).delete().eq('hash', key);
+    }
+}

package/apps/agents-server/src/utils/cdn/classes/DigitalOceanSpaces.ts

@@ -0,0 +1,119 @@
+import { GetObjectCommand, PutObjectCommand, PutObjectCommandInput, S3Client } from '@aws-sdk/client-s3';
+import { NotYetImplementedError } from '@promptbook-local/core';
+import { gzip, ungzip } from 'node-gzip';
+import { TODO_USE } from '../../../../../../src/utils/organization/TODO_USE';
+import { validateMimeType } from '../../validators/validateMimeType';
+import type { IFile, IIFilesStorageWithCdn } from '../interfaces/IFilesStorage';
+
+type IDigitalOceanSpacesConfig = {
+    readonly bucket: string;
+    readonly pathPrefix: string;
+    readonly endpoint: string;
+    readonly accessKeyId: string;
+    readonly secretAccessKey: string;
+    readonly cdnPublicUrl: URL;
+    readonly gzip: boolean;
+
+    // TODO: [⛳️] Probbably prefix should be in this config not on the consumer side
+};
+
+export class DigitalOceanSpaces implements IIFilesStorageWithCdn {
+    public get cdnPublicUrl() {
+        return this.config.cdnPublicUrl;
+    }
+
+    private s3: S3Client;
+
+    public constructor(private readonly config: IDigitalOceanSpacesConfig) {
+        this.s3 = new S3Client({
+            region: 'auto',
+            endpoint: 'https://' + config.endpoint,
+            credentials: {
+                accessKeyId: config.accessKeyId,
+                secretAccessKey: config.secretAccessKey,
+            },
+        });
+    }
+
+    public getItemUrl(key: string): URL {
+        return new URL(this.config.pathPrefix + '/' + key, this.cdnPublicUrl);
+    }
+
+    public async getItem(key: string): Promise<IFile | null> {
+        const parameters = {
+            Bucket: this.config.bucket,
+            Key: this.config.pathPrefix + '/' + key,
+        };
+
+        try {
+            const { Body, ContentType, ContentEncoding } = await this.s3.send(new GetObjectCommand(parameters));
+
+            // const blob = new Blob([await Body?.transformToByteArray()!]);
+
+            if (ContentEncoding === 'gzip') {
+                return {
+                    type: validateMimeType(ContentType),
+                    data: await ungzip(await Body!.transformToByteArray()),
+                };
+            } else {
+                return {
+                    type: validateMimeType(ContentType),
+                    data: (await Body!.transformToByteArray()) as Buffer,
+                };
+            }
+        } catch (error) {
+            if (error instanceof Error && error.name.match(/^NoSuchKey/)) {
+                return null;
+            } else {
+                throw error;
+            }
+        }
+    }
+
+    public async removeItem(key: string): Promise<void> {
+        TODO_USE(key);
+        throw new NotYetImplementedError(`DigitalOceanSpaces.removeItem is not implemented yet`);
+    }
+
+    public async setItem(key: string, file: IFile): Promise<void> {
+        // TODO: Put putObjectRequestAdditional into processedFile
+        const putObjectRequestAdditional: Partial<PutObjectCommandInput> = {};
+
+        let processedFile: IFile;
+        if (this.config.gzip) {
+            const gzipped = await gzip(file.data);
+            const sizePercentageAfterCompression = gzipped.byteLength / file.data.byteLength;
+            if (sizePercentageAfterCompression < 0.7) {
+                // consolex.log(`Gzipping ${key} (${Math.floor(sizePercentageAfterCompression * 100)}%)`);
+                processedFile = { ...file, data: gzipped };
+                putObjectRequestAdditional.ContentEncoding = 'gzip';
+            } else {
+                processedFile = file;
+                // consolex.log(`NOT Gzipping ${key} (${Math.floor(sizePercentageAfterCompression * 100)}%)`);
+            }
+        } else {
+            processedFile = file;
+        }
+
+        const uploadResult = await this.s3.send(
+            new PutObjectCommand({
+                Bucket: this.config.bucket,
+                Key: this.config.pathPrefix + '/' + key,
+                ContentType: processedFile.type,
+                ...putObjectRequestAdditional,
+                Body: processedFile.data,
+                // TODO: Public read access / just private to extending class
+                ACL: 'public-read',
+            }),
+        );
+
+        if (!uploadResult.ETag) {
+            throw new Error(`Upload result does not contain ETag`);
+        }
+    }
+}
+
+/**
+ * TODO: Implement Read-only mode
+ * TODO: [☹️] Unite with `PromptbookStorage` and move to `/src/...`
+ */

package/apps/agents-server/src/utils/cdn/classes/VercelBlobStorage.ts

@@ -0,0 +1,64 @@
+import { del, put } from '@vercel/blob';
+import { validateMimeType } from '../../validators/validateMimeType';
+import type { IFile, IIFilesStorageWithCdn } from '../interfaces/IFilesStorage';
+
+type IVercelBlobStorageConfig = {
+    readonly token: string;
+    readonly cdnPublicUrl: URL;
+    readonly pathPrefix?: string;
+    // Note: Vercel Blob automatically handles compression/serving
+};
+
+export class VercelBlobStorage implements IIFilesStorageWithCdn {
+    public get cdnPublicUrl() {
+        return this.config.cdnPublicUrl;
+    }
+
+    public constructor(private readonly config: IVercelBlobStorageConfig) {}
+
+    public getItemUrl(key: string): URL {
+        const path = this.config.pathPrefix ? `${this.config.pathPrefix}/${key}` : key;
+        return new URL(path, this.cdnPublicUrl);
+    }
+
+    public async getItem(key: string): Promise<IFile | null> {
+        const url = this.getItemUrl(key);
+
+        const response = await fetch(url);
+
+        if (response.status === 404) {
+            return null;
+        }
+
+        if (!response.ok) {
+            throw new Error(`Failed to fetch blob from ${url}: ${response.statusText}`);
+        }
+
+        const arrayBuffer = await response.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        const contentType = response.headers.get('content-type') || 'application/octet-stream';
+
+        return {
+            type: validateMimeType(contentType),
+            data: buffer,
+        };
+    }
+
+    public async removeItem(key: string): Promise<void> {
+        const url = this.getItemUrl(key).toString();
+        await del(url, { token: this.config.token });
+    }
+
+    public async setItem(key: string, file: IFile): Promise<void> {
+        const path = this.config.pathPrefix ? `${this.config.pathPrefix}/${key}` : key;
+
+        await put(path, file.data, {
+            access: 'public',
+            addRandomSuffix: false,
+            contentType: file.type,
+            token: this.config.token,
+            allowOverwrite: true, // <- TODO: This is inefficient, we should check first if the file exists and only then decide to overwrite or not
+            // Note: We rely on Vercel Blob for compression
+        });
+    }
+}

package/apps/agents-server/src/utils/cdn/interfaces/IFilesStorage.ts

@@ -0,0 +1,32 @@
+import type { string_mime_type } from '../../../../../../src/types/typeAliases';
+import type { IStorage } from './IStorage';
+
+export type IFile = {
+    // Maybe TODO name: string_name;
+    type: string_mime_type;
+    data: Buffer;
+};
+
+/**
+ * Represents storage that will store each keypair in a separate file.
+ */
+export type IFilesStorage = Omit<IStorage<IFile>, 'length' | 'clear' | 'key'>;
+
+/**
+ * Represents storage that can give public deterministic  URL for each file
+ */
+export type IIFilesStorageWithCdn = IFilesStorage & {
+    readonly cdnPublicUrl: URL;
+    getItemUrl(key: string): URL;
+};
+
+/**
+ * TODO: Probably not deterministic and async getItemUrl
+ * TODO: Probably just createUrlMaker
+ * TODO: List method
+ * TODO: Glob method
+ * TODO: Subfolder (similar to PrefixStorage) method
+ * TODO: Subscribe, list, sub(folder) should be part of LIB everstorage
+ * TODO: Probably implement observe through RxJS
+ * TODO: [☹️] Unite with `PromptbookStorage` and move to `/src/...`
+ */

package/apps/agents-server/src/utils/cdn/interfaces/IStorage.ts

@@ -0,0 +1,14 @@
+// Note: This is a simplified version of the IStorage interface based on the usage in the project.
+export type IStorage<T> = {
+    readonly length: Promise<number>;
+    clear(): Promise<void>;
+    getItem(key: string): Promise<T | null>;
+    key(index: number): Promise<string | null>;
+    removeItem(key: string): Promise<void>;
+    setItem(key: string, value: T): Promise<void>;
+};
+
+
+/**
+ * TODO: [☹️] Unite with `PromptbookStorage` and move to `/src/...`
+ */

package/apps/agents-server/src/utils/cdn/utils/getUserFileCdnKey.ts

@@ -0,0 +1,28 @@
+import hexEncoder from 'crypto-js/enc-hex';
+import sha256 from 'crypto-js/sha256';
+import type { string_uri } from '../../../../../../src/types/typeAliases';
+import { titleToName } from '../../../../../../src/utils/normalization/titleToName';
+import { nameToSubfolderPath } from './nameToSubfolderPath';
+
+/**
+ * Generates a path for the user content
+ */
+export function getUserFileCdnKey(file: Buffer, originalFilename: string): string_uri {
+    const hash = sha256(hexEncoder.parse(file.toString('hex'))).toString(/* hex */);
+    //    <- TODO: [🥬] Encapsulate sha256 to some private utility function
+
+    const originalFilenameParts = originalFilename.split('.');
+    const extension = originalFilenameParts.pop();
+    const name = titleToName(originalFilenameParts.join('.'));
+
+    const filename = name + '.' + extension;
+    // <- Note: [⛳️] Preserving original file name
+
+    return `user/files/${nameToSubfolderPath(hash).join('/')}/${filename}`;
+}
+
+/**
+ * TODO: [🌍] Unite this logic in one place
+ * TODO: Way to garbage unused uploaded files
+ * TODO: Probably separate util countBufferHash
+ */