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

7.9 KB
Raw Blame
import { createHash } from 'node:crypto';
import type { FilterQuery, Model, ProjectionType } from 'mongoose';
import type { AssistantQuery, IAssistant } from '~/types';
import { getTenantId, SYSTEM_TENANT_ID } from '~/config/tenantContext';
import { buildFilter, type FieldMap } from '~/utils/criteria';
import { createIndexesWithRetry } from '~/utils/retry';

const ASSISTANT_FIELDS: FieldMap<AssistantQuery> = {
  assistantId: 'assistant_id',
  user: 'user',
  avatarFilepath: 'avatar.filepath',
};

/** Translates domain assistant criteria into a Mongo filter. */
function assistantFilter(query: AssistantQuery): FilterQuery<IAssistant> {
  return buildFilter<AssistantQuery, FilterQuery<IAssistant>>(query, ASSISTANT_FIELDS);
}

export function createAssistantMethods(mongoose: typeof import('mongoose')): {
  updateAssistantDoc: (
    query: AssistantQuery,
    updateData: Partial<IAssistant>,
  ) => Promise<IAssistant | null>;
  updateAssistantAvatar: (
    query: { assistantId: string; user?: string },
    avatar: NonNullable<IAssistant['avatar']>,
    onInsert?: { user: string; endpoint: string },
  ) => Promise<(IAssistant & { previousAvatar?: IAssistant['avatar'] }) | null>;
  deleteAssistant: (query: AssistantQuery) => Promise<IAssistant | null>;
  deleteAssistants: (query: AssistantQuery) => Promise<number>;
  getAssistants: (
    query: AssistantQuery,
    select?: string | Record<string, number> | null,
  ) => Promise<IAssistant[]>;
  getAssistant: (
    query: AssistantQuery,
    projection?: ProjectionType<IAssistant>,
  ) => Promise<IAssistant | null>;
  ensureAssistantIndexes: () => Promise<void>;
} {
  const Assistant = () => mongoose.models.Assistant as Model<IAssistant>;
  let assistantIndexesPromise: Promise<void> | null = null;

  function ensureAssistantIndexes(): Promise<void> {
    if (!assistantIndexesPromise) {
      assistantIndexesPromise = createIndexesWithRetry(Assistant()).catch((error) => {
        assistantIndexesPromise = null;
        throw error;
      });
    }
    return assistantIndexesPromise;
  }

  /**
   * Update an assistant with new data without overwriting existing properties,
   * or create a new assistant if it doesn't exist.
   */
  async function updateAssistantDoc(
    query: AssistantQuery,
    updateData: Partial<IAssistant>,
  ): Promise<IAssistant | null> {
    const options = { new: true, upsert: true };
    return await Assistant()
      .findOneAndUpdate(assistantFilter(query), updateData, options)
      .lean<IAssistant>();
  }

  /** Updates avatar and absent identity atomically; unmatched references return null without insert data. */
  async function updateAssistantAvatar(
    query: { assistantId: string; user?: string },
    avatar: NonNullable<IAssistant['avatar']>,
    onInsert?: { user: string; endpoint: string },
  ): Promise<(IAssistant & { previousAvatar?: IAssistant['avatar'] }) | null> {
    if (
      typeof query?.assistantId !== 'string' ||
      query.assistantId.trim().length === 0 ||
      !Object.prototype.hasOwnProperty.call(query, 'assistantId')
    ) {
      throw new TypeError('assistantId must be a nonempty string');
    }
    if (
      query.user !== undefined &&
      (typeof query.user !== 'string' ||
        query.user.trim().length === 0 ||
        !Object.prototype.hasOwnProperty.call(query, 'user'))
    ) {
      throw new TypeError('user must be a nonempty string');
    }

    if (
      onInsert !== undefined &&
      (typeof onInsert?.user !== 'string' ||
        onInsert.user.trim().length === 0 ||
        typeof onInsert.endpoint !== 'string' ||
        onInsert.endpoint.trim().length === 0 ||
        (query.user !== undefined && query.user !== onInsert.user))
    ) {
      throw new TypeError('Avatar insert data must identify the authorized user and endpoint');
    }

    const { assistantId, user } = query;
    const insertData = onInsert && { user: onInsert.user, endpoint: onInsert.endpoint };
    let reference = await Assistant().findOne(assistantFilter({ assistantId })).lean<IAssistant>();
    if (!reference) {
      if (!insertData) {
        return null;
      }
      // The built-in unique _id index arbitrates concurrent initialization across replicas.
      const tenantId = getTenantId();
      const tenant = tenantId && tenantId !== SYSTEM_TENANT_ID ? tenantId : null;
      const _id = new mongoose.Types.ObjectId(
        createHash('sha256')
          .update(JSON.stringify([tenant, assistantId]))
          .digest('hex')
          .slice(0, 24),
      );
      try {
        const created = await Assistant().create({
          _id,
          assistant_id: assistantId,
          ...insertData,
          avatar,
        });
        return created.toObject<IAssistant>();
      } catch (error) {
        if (
          typeof error !== 'object' ||
          error == null ||
          !('code' in error) ||
          error.code !== 11000
        ) {
          throw error;
        }
        reference = await Assistant()
          .findOne({ _id, assistant_id: assistantId })
          .lean<IAssistant>();
        if (!reference) {
          throw error;
        }
      }
    }
    if (user !== undefined && reference.user?.toString() !== user) {
      if (!insertData) {
        return null;
      }
      if (reference.user != null) {
        throw new Error('Assistant ownership changed before the avatar update');
      }
    }

    const missingUser = reference.user == null;
    const missingEndpoint = reference.endpoint == null || reference.endpoint === '';
    if (
      (!insertData || (!missingUser && !missingEndpoint)) &&
      reference.avatar?.filepath === avatar.filepath &&
      reference.avatar.source === avatar.source
    ) {
      return reference;
    }

    // Avatar and backfill share one identity guard, so a lost race cannot partially mutate the row.
    const updated = await Assistant()
      .findOneAndUpdate(
        {
          _id: reference._id,
          assistant_id: assistantId,
          user: reference.user ?? null,
          endpoint: reference.endpoint ?? null,
          avatar: reference.avatar ?? null,
        },
        {
          $set: {
            avatar,
            ...(insertData && missingUser ? { user: insertData.user } : {}),
            ...(insertData && missingEndpoint ? { endpoint: insertData.endpoint } : {}),
          },
        },
        { new: true },
      )
      .lean<IAssistant>();
    if (!updated) {
      throw new Error('Assistant identity changed before the avatar update');
    }
    return Object.assign(updated, { previousAvatar: reference.avatar });
  }

  /**
   * Retrieves an assistant document based on the provided search params.
   */
  async function getAssistant(
    query: AssistantQuery,
    projection?: ProjectionType<IAssistant>,
  ): Promise<IAssistant | null> {
    await ensureAssistantIndexes();
    return await Assistant().findOne(assistantFilter(query), projection).lean<IAssistant>();
  }

  /**
   * Retrieves all assistants that match the given search parameters.
   */
  async function getAssistants(
    query: AssistantQuery,
    select: string | Record<string, number> | null = null,
  ): Promise<IAssistant[]> {
    const search = Assistant().find(assistantFilter(query));

    return await (select ? search.select(select) : search).lean<IAssistant[]>();
  }

  /**
   * Deletes an assistant based on the provided search params.
   */
  async function deleteAssistant(query: AssistantQuery): Promise<IAssistant | null> {
    return await Assistant().findOneAndDelete(assistantFilter(query));
  }

  /**
   * Deletes all assistants matching the given search parameters.
   */
  async function deleteAssistants(query: AssistantQuery): Promise<number> {
    const result = await Assistant().deleteMany(assistantFilter(query));
    return result.deletedCount;
  }

  return {
    updateAssistantDoc,
    updateAssistantAvatar,
    deleteAssistant,
    deleteAssistants,
    getAssistants,
    getAssistant,
    ensureAssistantIndexes,
  };
}

export type AssistantMethods = ReturnType<typeof createAssistantMethods>;