Automatic redirects NextJs - Sanity Studio V3

// schemas/redirect
import { defineField } from 'sanity';

export default defineField({
  title: 'Redirect',
  name: 'redirect',
  type: 'document',
  initialValue: {
    permanent: true,
  },
  fields: [
    {
      title: 'from',
      name: 'source',
      type: 'string',
      description: 'The path to redirect from',
      validation: (Rule) =>
        Rule.required().custom((value) => {
          if (typeof value !== 'string') {
            return 'The path must be a string';
          }
          if (value === '/') {
            return 'The root path cannot be redirected';
          }
          if (!value.startsWith('/')) {
            return 'The path must start with a /';
          }
          return true;
        }),
    },

    {
      title: 'to',
      name: 'destination',
      type: 'string',
      description: 'The path to redirect to',
      validation: (Rule) =>
        Rule.required().custom((value) => {
          if (typeof value !== 'string') {
            return 'The path must be a string';
          }
          if (!value.startsWith('/')) {
            return 'The path must start with a /';
          }
          return true;
        }),
    },
    {
      title: 'Permanent',
      name: 'permanent',
      type: 'boolean',
      description: 'Whether the redirect is permanent or temporary',
      validation: (Rule) => Rule.required(),
    },
  ],
});

// next.config.js
const { resolveRedirects } = require('./sanity/resolveRedirects');

const nextConfig = {
   // ... all your next config settings,
  async redirects() {
    const redirects = await resolveRedirects();
    return redirects;
  },
};


// /sanity/resolveRedirects.js
const sanity = require('next-sanity');
const config = require('./sanity-config'); 

function resolveRedirects() {
  const sanityClient = sanity.createClient(config);
  return sanityClient.fetch(`
  *[_type == "redirect" && !(_id in path("drafts.**"))]{
        source, destination, permanent
    }`);
}

module.exports = { resolveRedirects };

// sanity/actions/PublishAndRedirect.tsx

import { useState, useEffect } from 'react';
import {
  DocumentActionProps,
  useClient,
  useValidationStatus,
  useDocumentOperation,
} from 'sanity';
import { useToast } from '@sanity/ui';
// Custom function that resolves the path from your document.
import { resolveProductionPath } from '../resolveProductionUrl';


export default function PublishAndRedirect(props: DocumentActionProps) {
  const client = useClient();
  const toast = useToast();
  const { publish } = useDocumentOperation(props.id, props.type);
  const validation = useValidationStatus(props.id, props.type);
  // Check if the document is valid before allowing the user to publish it.
  const isValid =
    !validation.isValidating &&
    validation.validation.filter((v) => v.level === 'error').length === 0;

  const [isPublishing, setIsPublishing] = useState(false);
  const draftPath = resolveProductionPath(props.draft);
  const publishedPath = resolveProductionPath(props.published);

  useEffect(() => {
    // if the isPublishing state was set to true and the draft has changed
    // to become `null` the document has been published
    if (isPublishing && !props.draft) {
      setIsPublishing(false);
    }
  }, [props.draft]);

  const handlePublish = async () => {
    // This will update the button text
    setIsPublishing(true);
    // Create the redirect
    await client.create({
      _type: 'redirect',
      source: publishedPath,
      destination: draftPath,
      permanent: true,
    });
    
    // Notify the user the redirect was created.
    toast.push({
      closable: true,
      duration: 5000,
      status: 'success',
      title: `Redirect created`,
      description: `Redirect from ${publishedPath} to ${draftPath}`,
    });
    // Perform the publish
    publish.execute();
    // Signal that the action is completed
    props.onComplete();
  };
  if (publishedPath && draftPath && draftPath !== publishedPath) {
    return {
      disabled: !!publish.disabled || !isValid,
      tone: 'positive',
      label: isPublishing ? 'Publishing…' : 'Publish & Redirect',
      onHandle: handlePublish,
    } as const;
  }
  
  return null;
}

// sanity.config.ts
import PublishAndRedirect from "./sanity/actions/PublishAndRedirect"

export default defineConfig({
  // ... all your previous config.
  document: {
    actions: (prev) => [PublishAndRedirect, ...prev],
  },
});