Skip to content

Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active

5.3 KB
Raw Blame
import type { Model } from 'mongoose';
import logger from '~/config/winston';

interface IPreset {
  user?: string;
  presetId?: string;
  order?: number;
  defaultPreset?: boolean;
  tools?: (string | { pluginKey?: string })[];
  updatedAt?: Date;
  [key: string]: unknown;
}

export function createPresetMethods(mongoose: typeof import('mongoose')): {
  getPresets: (
    user: string,
    filter?: Record<string, unknown>,
  ) => Promise<
    | (import('mongoose').FlattenMaps<{
        [x: string]: unknown;
        user?: string | undefined;
        presetId?: string | undefined;
        order?: number | undefined;
        defaultPreset?: boolean | undefined;
        tools?:
          | (
              | string
              | {
                  pluginKey?: string | undefined;
                }
            )[]
          | undefined;
        updatedAt?: Date | undefined;
      }> & {
        _id: import('mongoose').Types.ObjectId;
      } & {
        __v: number;
      })[]
    | {
        message: string;
      }
  >;
  savePreset: (
    user: string,
    {
      presetId,
      newPresetId,
      defaultPreset,
      ...preset
    }: {
      presetId?: string;
      newPresetId?: string;
      defaultPreset?: boolean;
      [key: string]: unknown;
    },
  ) => Promise<
    | IPreset
    | {
        message: string;
      }
  >;
  deletePresets: (
    user: string,
    filter?: Record<string, unknown>,
  ) => Promise<import('mongodb').DeleteResult>;
} {
  /**
   * Retrieves all presets for a user, sorted by order then updatedAt.
   */
  async function getPresets(
    user: string,
    filter: Record<string, unknown> = {},
  ): Promise<
    | (import('mongoose').FlattenMaps<{
        [x: string]: unknown;
        user?: string | undefined;
        presetId?: string | undefined;
        order?: number | undefined;
        defaultPreset?: boolean | undefined;
        tools?:
          | (
              | string
              | {
                  pluginKey?: string | undefined;
                }
            )[]
          | undefined;
        updatedAt?: Date | undefined;
      }> & {
        _id: import('mongoose').Types.ObjectId;
      } & {
        __v: number;
      })[]
    | {
        message: string;
      }
  > {
    try {
      const Preset = mongoose.models.Preset as Model<IPreset>;
      const presets = await Preset.find({ ...filter, user }).lean();
      const defaultValue = 10000;

      presets.sort((a, b) => {
        const orderA = a.order !== undefined ? a.order : defaultValue;
        const orderB = b.order !== undefined ? b.order : defaultValue;

        if (orderA !== orderB) {
          return orderA - orderB;
        }

        return new Date(b.updatedAt ?? 0).getTime() - new Date(a.updatedAt ?? 0).getTime();
      });

      return presets;
    } catch (error) {
      logger.error('[getPresets] Error getting presets', error);
      return { message: 'Error retrieving presets' };
    }
  }

  /**
   * Saves a preset. Handles default preset logic and tool normalization.
   */
  async function savePreset(
    user: string,
    {
      presetId,
      newPresetId,
      defaultPreset,
      ...preset
    }: {
      presetId?: string;
      newPresetId?: string;
      defaultPreset?: boolean;
      [key: string]: unknown;
    },
  ): Promise<
    | IPreset
    | {
        message: string;
      }
  > {
    try {
      const Preset = mongoose.models.Preset as Model<IPreset>;
      const setter: Record<string, unknown> = { $set: {} };
      const { user: _unusedUser, ...cleanPreset } = preset;
      const update: Record<string, unknown> = { presetId, ...cleanPreset };
      if (preset.tools && Array.isArray(preset.tools)) {
        update.tools =
          (preset.tools as Array<string | { pluginKey?: string }>)
            .map((tool) => (typeof tool === 'object' && tool?.pluginKey ? tool.pluginKey : tool))
            .filter((toolName) => typeof toolName === 'string') ?? [];
      }
      if (newPresetId) {
        update.presetId = newPresetId;
      }

      if (defaultPreset) {
        update.defaultPreset = defaultPreset;
        update.order = 0;

        /** One write demotes every other default, instead of a read then a by-id update. */
        await Preset.updateMany(
          { user, defaultPreset: true, ...(presetId != null && { presetId: { $ne: presetId } }) },
          { $unset: { defaultPreset: '', order: '' } },
        );
      } else if (defaultPreset === false) {
        update.defaultPreset = undefined;
        update.order = undefined;
        setter['$unset'] = { defaultPreset: '', order: '' };
      }

      setter.$set = update;
      return await Preset.findOneAndUpdate({ presetId, user }, setter, {
        new: true,
        upsert: true,
      });
    } catch (error) {
      logger.error('[savePreset] Error saving preset', error);
      return { message: 'Error saving preset' };
    }
  }

  /**
   * Deletes presets matching the given filter for a user.
   */
  async function deletePresets(
    user: string,
    filter: Record<string, unknown> = {},
  ): Promise<import('mongodb').DeleteResult> {
    const Preset = mongoose.models.Preset as Model<IPreset>;
    const deleteCount = await Preset.deleteMany({ ...filter, user });
    return deleteCount;
  }

  return {
    getPresets,
    savePreset,
    deletePresets,
  };
}

export type PresetMethods = ReturnType<typeof createPresetMethods>;