Issues with implementing custom features in Sanity v3, including accessing the sanity client within the prepare function and resolving errors with the getCliClient method...

preview: {
  select: {
    title: 'title',
    id: '_id'
  },
  prepare: async ({title, id}) => {
    // old approach, some pre-defined client from the parts system
    const {title: parentTitle } = await client.fetch('some query');

    // new approach with useClient hook won't work
    return {
      title: parentTitle + "-" + title,
    }
  }
}

const client = getCliClient({ apiVersion: '2021-08-21' })

import { getCliClient } from "sanity/cli";

const client = getCliClient({ apiVersion: process.env.SANITY_STUDIO_VERSION });

export default defineType({
  name: "novel",
  title: "Novel",
  type: "document",
  fields: [
    defineField({
      name: "author",
      title: "Author",
      type: "reference",
      to: { type: "author" }
    })
  ],
  initialValue: async () => ({
    author: await client.fetch(`
      *[_type == "author"][0]{
        "_type": "reference",
        "_ref": _id
      }
    `)
  })
})

initialValue: async (props, context) =>  {
          const {getClient} = context
          const client = getClient({ apiVersion: '2022-12-14'})
          //other code. 
        }

export default {
  name: 'moduleRef',
  title: 'Module Reference',
  type: 'document',
  icon: GrFlows,
  i18n: true,
  initialValue: {
    __i18n_lang: 'en',
  },
  fields: [
    {
      name: 'moduleRef',
      type: 'reference',
      title: 'Module',
      to: [{ type: 'module' }],
      options: { filter: ` __i18n_lang == 'en'` },
    },
    {
      title: 'Module ID',
      name: 'moduleId',
      type: 'slug',
      description: 'This ID is necessary if some link need to scrolls to this specific module.',
    },
    {
      title: 'Variant',
      name: 'variant',
      type: 'string',
      components: {
        input: VariantField,
      },
      localize: false,
      hidden: async ({ parent }, context) => {
        console.log(context);
        const { getClient } = context;
        const client = getClient({ apiVersion: '2022-12-14' });
        const moduleData = await sanityClient.fetch(`
          *[_id == '${parent.moduleRef?._ref}'][0]
        `);
        console.log({ moduleData });
      },
    },
  ],

//Schema
export default {
  name: 'page',
  title: 'Pages',
  type: 'document',
  icon: GrDomain,
  i18n: true,
  initialValue: {
    __i18n_lang: 'en',
  },
  preview: {
    select: {
      title: 'internalName',
    },
  },
  fields: [
    {
      name: 'internalName',
      type: 'string',
      title: 'Internal name',
      description: 'For internal use within Sanity',
      localize: false,
    },
    {
      name: 'slug',
      type: 'slug',
      title: 'Slug',
      description: 'Used to generate the page URL (eg., "/careers" or "/contact")',
      validation: (rule: Rule): Rule => rule.required().error('You need a unique slug for the URL'),
      options: {
        source: 'internalName',
        maxLength: 200,
        isUnique: isSlugUnique,
      },
    },

//Function
export const isSlugUnique = (_, context: ConfigContext) => {
  const { getClient } = context;
  const client = getClient({ apiVersion: '2022-12-14' });
  return createIsSlugUnique(client);
};

isUnique: async (value, {client}) => {}

const isSlugUnique = async (value, {client}) => {
  const slugs = await client.fetch(`*[defined(slug)].slug.current`)

  return !slugs.includes(value)
}

//other code 

  {
      name: 'slug',
      title: 'Slug',
      type: 'slug',
      options: {
        source: 'title',
        maxLength: 96,
        isUnique: isSlugUnique,
      },
    },

import { getCliClient } from 'sanity/cli'
const client = getCliClient({ apiVersion: '2021-10-21' })

async function asyncCampaignCodeGenerator(input, context) {
  var chars = 'acdefhiklmnoqrstuvwxyz0123456789'.split('');
  var codeGen = '';
  for (var i = 0; i < 8; i++) {
    var x = Math.floor(Math.random() * chars.length);
    codeGen += chars[x];
  }
  const query = `*[_id == "${input}"]{ "countryCode": jurisdiction->code }`
  const params = { code: input }
  return context.client.fetch(query, params).then(code =>  `${ code[0]?.countryCode || 'G' + '-' + codeGen.toUpperCase()}`)
}

defineField({
      name: 'code',
      type: 'slug',
      title: 'Campaign Code',
      description: 'This will be the unique campaign code',
      options: {
        source: '_id',
        slugify: asyncCampaignCodeGenerator
      },
      validation: Rule => Rule.required()
    })