next#GetStaticProps TypeScript Examples

getStaticProps: GetStaticProps = async () => {
  const sites = await prisma.notionSites.findMany({
    where: {
      inShowcase: true,
    },
    select: {
      siteName: true,
      subdomain: true,
      ogImageUrl: true,
      id: true,
    },
    orderBy: {
      createdAt: 'desc',
    },
  });

  return {
    props: {
      sites,
    },
    revalidate: 1800,
  };
}

getStaticProps: GetStaticProps = async ({ params }) => {
  const siteId = params.siteId as string;

  const res = await fetch(process.env.HARPERDB_URL, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      Authorization: `Basic ${process.env.HARPERDB_KEY}`,
    },
    body: JSON.stringify({
      operation: 'sql',
      sql: `SELECT * FROM site_schema.sites where id = "${siteId}"`,
    }),
  });
  const data: HarperDBRecord = (await res.json())[0];

  return {
    props: {
      id: siteId,
      title: data.title || '',
      isLoginBlocked: data.is_login_blocked,
      caption: data.cap,
      logoUrl: data.logo_url || '',
    },
  };
}

getStaticProps: GetStaticProps = async ({ params }) => {
  const postFilePath = path.join(POSTS_PATH, `${params.slug}.mdx`);
  const source = fs.readFileSync(postFilePath);

  const { content, data } = matter(source);

  const mdxSource = await renderToString(content, {
    components,
    // Optionally pass remark/rehype plugins
    mdxOptions: {
      remarkPlugins: [require('remark-code-titles')],
      rehypePlugins: [mdxPrism, rehypeSlug, rehypeAutolinkHeadings],
    },
    scope: data,
  });

  return {
    props: {
      source: mdxSource,
      frontMatter: data,
    },
  };
}

getStaticProps: GetStaticProps = async (context) => {
  const carId = context.params.carId as string;
  const car = await api.getCar(carId);
  console.log(`Fetch car: ${JSON.stringify(car, null, 2)}`);

  return {
    props: {
      car,
    },
  };
}

getStaticProps: GetStaticProps = async ({ params }) => {
  return {
    props: {
      // @ts-ignore
      posts: getAuthors()[params.authorSlug],
      // @ts-ignore
      slug: params.authorSlug,
    },
  };
}

getStaticProps: GetStaticProps = ctx => {
  return MDXProps(
    ({ readMarkdownFile, getArrayParam }) => {
      return readMarkdownFile('docs/', getArrayParam('slug'), { importPartialMarkdown: true });
    },
    ctx,
    { getRoutes }
  );
}

getStaticProps: GetStaticProps<{
  rules: any[];
  province: Province;
  buildTime: number;
}> = async ({ params }) => {
  const { province } = params;
  const selectedProvince = italianRegions.find((p) => p.urlName === province);
  const restrictions = getActiveRestrictions(selectedProvince);
  return {
    props: {
      restrictions,
      province: selectedProvince,
      buildTime: Date.now(),
    },
  };
}

getStaticProps: GetStaticProps<Props> = async function () {
	const pinnedRepos = await fetch(
		'https://gh-pinned-repos.egoist.sh/?username=alii',
	).then(async response => response.json() as Promise<PinnedRepo[]>);

	const lanyard = await fetch(
		`https://api.lanyard.rest/v1/users/${DISCORD_ID}`,
	);

	const lanyardBody = (await lanyard.json()) as LanyardResponse;

	if ('error' in lanyardBody) {
		throw new LanyardError(lanyard.status, lanyardBody.error.message);
	}

	return {
		props: {pinnedRepos, lanyard: lanyardBody.data},
		revalidate: 120,
	};
}

getStaticProps: GetStaticProps = async (props) => {
  try {
    const film = await getFilm(props.params?.id as string);

    return { props: { film } };
  } catch (err: any) {
    return { props: { errors: err.message } };
  }
}

getStaticProps: GetStaticProps = async (context) => {
	const post = await getPostBySlug(context.params.slug);
	const tweets = await getTweets(post.tweetIDs);
	const { prevPage, nextPage } = getPagination(context.params.slug);

	return {
		props: {
			post,
			tweets,
			pagination: {
				prevPage,
				nextPage
			}
		}
	};
}

getStaticProps: GetStaticProps = async (
  context: GetStaticPropsContext
) => {
  const { params } = context;
  if (!params) {
    throw Error("params required");
  }
  const id = params["id"];
  if (!_.isString(id)) {
    throw Error("id required");
  }

  try {
    const [body, note] = await Promise.all([getNoteBody(id), getNoteMeta(id)]);
    const noteData = getNotes();
    const customHeadContent: string | null = await getCustomHead();
    const { notes, noteIndex } = noteData;
    const collectionChildren = note.custom?.has_collection
      ? prepChildrenForCollection(note, notes, noteIndex)
      : null;
    const props: DendronNotePageProps = {
      note,
      body,
      noteIndex,
      collectionChildren,
      customHeadContent,
      config: await getConfig(),
    };

    return {
      props,
    };
  } catch (err) {
    // eslint-disable-next-line no-console
    console.log(error2PlainObject(err as DendronError));
    throw err;
  }
}

getStaticProps: GetStaticProps = async ({ locale: localeVal }) => {
  const locale = getLocale(localeVal)

  const s3 = new S3({
    'accessKeyId': process.env.AWS_ACCESS_KEY_ID_BEDROCK,
    'secretAccessKey': process.env.AWS_SECRET_ACCESS_KEY_BEDROCK,
    'region': 'us-east-1',
  })

  let versions: PackVersions = {}
  let paths: string[] = []

  try {
    const objects = await s3.listObjectsV2({ Bucket: process.env.AWS_BUCKET_NAME_BEDROCK || '' }).promise()
    if (objects.Contents)
      paths = objects.Contents.filter(c => c.Key && c.Key?.endsWith('.zip')).map(c => c.Key!)
  } catch (e) {
    Log.error('Could not list items from bucket!')
  }

  for (let path of paths) {
    const [ folder, name ] = path.split('/')
    if (folder && name) {
      const version = name.replace('.zip', '')
      if (!versions[version]) versions[version] = [false, false]
      if (folder === 'behaviours') versions[version][0] = true
      if (folder === 'resources') versions[version][1] = true
    }
  }

  return { props: { versions, ...await serverSideTranslations(locale, ['common']) } }
}

getStaticProps: GetStaticProps = async (ctx) => {
  const { params } = ctx;
  const { data, content } = getBlogBySlug(params?.slug);
  const mdxPrism = require("mdx-prism");
  const mdxSource = await serialize(content, {
    mdxOptions: {
      rehypePlugins: [mdxPrism],
    },
  });
  return {
    props: {
      ...data,
      mdxSource,
    },
  };
}

getStaticProps: GetStaticProps = async () => {
  const lastWeekData = await getLastWeek();
  const lastWeek = {
    success: true,
    protocols: lastWeekData.sort((a: any, b: any) => b.fees[0].fee - a.fees[0].fee),
  };
  const protocols = getIDs().map((id: string) => ({ id, ...getMetadata(id) }));

  return { props: { lastWeek, protocols }, revalidate: 60 * 10 };
}

getStaticProps: GetStaticProps<Props> = () => {
  const { contributors } = JSON.parse(
    fs.readFileSync("./thankyou.json").toString()
  );
  return Promise.resolve({
    props: {
      recurring: RECURRING.map((title) => ({ ...contributors[title], title })),
      oneTime: ONE_TIME.map((title) => ({ ...contributors[title], title })),
    },
  });
}

getStaticProps: GetStaticProps = async ({ locale, params }) => {
  const applications: Appstream[] = await fetchCategory(
    params.category as keyof typeof Category
  )

  return {
    props: {
      ...(await serverSideTranslations(locale, ['common'])),
      applications,
    },
    revalidate: 3600,
  }
}

getStaticProps: GetStaticProps<Props> = async (context) => {
  const products = await prisma?.product.findMany({
    where: {
      active: true,
    },
    include: {
      prices: {
        where: {
          active: true,
        },
      },
    },
  });

  return {
    props: {
      products,
    },
  };
}

getStaticProps: GetStaticProps = async (ctx) => {
  const { slug } = ctx.params

  const { data } = await api.get(`/episodes/${slug}`)

  const episode = {
    id: data.id,
    title: data.title,
    thumbnail: data.thumbnail,
    members: data.members,
    publishedAt: format(parseISO(data.published_at), 'd MMM yy', { locale: ptBR }),
    duration: Number(data.file.duration),
    durationAsString: convertDurationToTimeString(Number(data.file.duration)),
    description: data.description,
    url: data.file.url
  }
  
  return {
    props: {
      episode,
    },
    revalidate: 60 * 60 * 24, // 24 hours
  }
}

getStaticProps: GetStaticProps = async ({
  params,
  preview = false,
}) => {
  const settings = await getSettings(preview);
  const data = await getDocBySlug(params.slug as string, preview);

  return {
    props: { data, preview, settings },
    revalidate: 1,
  };
}

getStaticProps: GetStaticProps<
  { date: string; type: string; pathList: string[] },
  { type: string; pathParts: string[] }
> = ({ params }) => ({
  props: {
    date: new Date().toISOString(),
    type: params.type,
    pathList: params.pathParts?.map((pathPart) => `Part ${pathPart}`) || [],
  },
})

getStaticProps: GetStaticProps = async ({ locale }) => {
  if (!['en-US', 'en-NL'].includes(locale)) {
    return {
      notFound: true,
    }
  }

  return {
    props: {},
  }
}

getStaticProps: GetStaticProps = async () => {
  let spotify:
    | SpotifyCurrentTrack
    | SpotifyRecentTracks = await getCurrentlyPlaying()
  if (spotify === null) {
    spotify = await getRecentlyPlayed()
  }

  const letterboxd = await getRecentMovies()
  const steam = await getRecentGames()
  const notion = await getDoingNow()
  return {
    props: {
      spotify,
      letterboxd,
      steam,
      notion,
    },
    revalidate: 60,
  }
}

getStaticProps: GetStaticProps<{
  authorDetails: { mdxSource: string; frontMatter: AuthorFrontMatter };
}> = async () => {
  const authorDetails = await getFileBySlug<AuthorFrontMatter>('authors', [
    'default',
  ]);
  const { mdxSource, frontMatter } = authorDetails;
  return { props: { authorDetails: { mdxSource, frontMatter } } };
}

getStaticProps: GetStaticProps<GuidelinesProps> = async () => {
	const res = await fetch(SpecialEndPoints.Github.Content('koreanbots', 'terms', 'guidelines.md'))
	const json = await res.json()
	return {
		props: {
			content: Buffer.from(json.content, 'base64').toString('utf-8')
		}
	}
}

getStaticProps: GetStaticProps = async ({ params }) => {
  const doc: string = await fs.readFile(resolve('../LICENSE'), 'utf-8');

  const licenseText = doc
    .split(/\n{2,}/)
    .map(paragraph => paragraph.split('\n').join(' ').trim())
    .filter(Boolean);

  return { props: { licenseText } };
}

getStaticProps: GetStaticProps = async ({ params }) => {
  const slugParams: string = params ? String(params.slug) : ''
  const post: IPost = await getPostBySlug(slugParams)

  return {
    props: { post },
    revalidate: 3
  }
}

export function withStaticTranslation(gsp: GetStaticProps): GetStaticProps {
  return async (ctx) => {
    const ssp = await gsp(ctx);
    ssp.revalidate = 60 * 60;
    const locale = ctx.locale;
    if (!locale) {
      return ssp;
    }
    const translation = (await import(`../locales/${ctx.locale}/messages`))
      .messages;
    if ('props' in ssp) {
      return { ...ssp, props: { ...ssp.props, translation } };
    }
    return ssp;
  };
}

getStaticProps: GetStaticProps = async ({ params }) => {
  const to = params?.to as string | undefined

  const splitArr = to?.split('-to-')

  const from = splitArr && splitArr.length > 1 ? splitArr[0] : null

  const splitTo = splitArr?.pop()

  return { props: { to: splitTo, from: from } }
}

getStaticProps: GetStaticProps = async () => {
  // just to be conforming with eslint
  await Promise.resolve()

  return {
    revalidate: 10,
    props: {},
  }
}