sexy/packages/backend/src/graphql/resolvers/models.ts

import { builder } from "../builder";
import { ModelType } from "../types/index";
import { users, user_photos, files } from "../../db/schema/index";
import { eq, and, desc } from "drizzle-orm";

async function enrichModel(db: any, user: any) {
  // Fetch photos
  const photoRows = await db
    .select({ id: files.id, filename: files.filename })
    .from(user_photos)
    .leftJoin(files, eq(user_photos.file_id, files.id))
    .where(eq(user_photos.user_id, user.id))
    .orderBy(user_photos.sort);

  return {
    ...user,
    photos: photoRows.map((p: any) => ({ id: p.id, filename: p.filename })),
  };
}

builder.queryField("models", (t) =>
  t.field({
    type: [ModelType],
    args: {
      featured: t.arg.boolean(),
      limit: t.arg.int(),
    },
    resolve: async (_root, args, ctx) => {
      let query = ctx.db
        .select()
        .from(users)
        .where(eq(users.role, "model"))
        .orderBy(desc(users.date_created));

      if (args.limit) {
        query = (query as any).limit(args.limit);
      }

      const modelList = await query;
      return Promise.all(modelList.map((m: any) => enrichModel(ctx.db, m)));
    },
  }),
);

builder.queryField("model", (t) =>
  t.field({
    type: ModelType,
    nullable: true,
    args: {
      slug: t.arg.string({ required: true }),
    },
    resolve: async (_root, args, ctx) => {
      const model = await ctx.db
        .select()
        .from(users)
        .where(and(eq(users.slug, args.slug), eq(users.role, "model")))
        .limit(1);

      if (!model[0]) return null;
      return enrichModel(ctx.db, model[0]);
    },
  }),
);