Evanston Mayor Daniel Biss and City <strong>Clerk</strong> Stephanie Mendoza chronicled hefty workloads when they sat Wednesday for interviews.

Mayor, city clerk give measured responses to Compensation Committee - Evanston RoundTable

Former Colleton County <strong>Clerk</strong> of Court Becky Hill faces 76 ethics violations brought by officials in South Carolina

Alex Murdaugh clerk misused $20k from funds on bonus, pet food and other personal expenses, complaint reveals | The Independent

South Carolina court <strong>clerk</strong> Becky Hill, who presided over the Alex Murdaugh trial, is now accused of 76 counts of misconduct by the State Ethics Commission.

Alex Murdaugh court clerk Becky Hill misused thousands of dollars on paint supplies, dog bed, gifts: complaint

South Carolina officials have filed 76 counts of ethics violations against the court <strong>clerk</strong> who handled the Alex Murdaugh murder trial

Clerk over Murdaugh trial spent thousands on bonuses, meals, gifts: ethics complaint - ABC News

Former Colleton County <strong>Clerk</strong> of Court Becky Hill may have abused office for personal gain during Murdaugh trial, SC Ethics Commission says.

76 ethics allegations say ex-Clerk of Court Becky Hill abused post for own gain

The former Colleton County <strong>clerk</strong> of court who served during the Alex Murdaugh murder trial is accused of 76 ethics violations, according to documents from the State Ethics Commission.

Former Colleton County clerk of court accused of dozens of ethics violations

Clerk

clerk

In the web development field, auth (authentication + authorization) plays a vital role in securing user access and protecting sensitive data. Authentication involves verifying the user’s identity, and Authorization is about granting them appropriate access to the application’s resources. That said, it’s not easy. Implementing auth solely in the frontend is easy, but is usually a terrible idea. Even when done in the backend, it can have its drawbacks. This article explores these limitations and presents a compelling third alternative: the . Backends-for-Frontends (BFF) pattern By adopting this approach, developers can enhance security, improve performance, and achieve greater flexibility in their authentication implementation. Essentially, it’s the perfect pattern for this problem. Additionally, we’ll examine how WunderGraph simplifies the process of implementing auth with a BFF. So let’s get going! Why Frontend Auth Falls Short Let’s first clear the air and analyze why doing front-end auth is such a bad idea (because, let’s face it, it might seem easy, but it’s a terrible way to implement it). Too Exposed Frontend auth involves embedding auth logic in the client-side code, making it vulnerable to inspection by malicious actors. With access to the JS bundle, anyone can analyze and exploit potential weaknesses, jeopardizing the security of the system. Yes, you can obfuscate the code, minimize it and make it literally unreadable by humans. But anyone with enough free time and a Developer’s Console (which is on every major browser) can break your logic and “hack” your auth. Messy Frontend Code Handling auth logic in the frontend increases the burden on frontend teams, leading to slower development cycles. Moreover, frontend code becomes tightly coupled with the auth implementation, hindering scalability and adaptability. In other words, you’re adding code where you shouldn’t, and that only plays against you and your team. Multiple Clients Complexity What if your back-end can be used by different clients (e.g., desktop, mobile app, gaming consoles)? In that case, every different client will have to re-implement the entire auth logic. Does that sound reasonable to you? Even worse, what if you’re developing a platform that can be used by anyone? Then you’ll have countless client applications having to re-invent the authentication wheel. Madness! MADNESS I SAY! The “Prevent Tracking” Option Enabling privacy features that aim to prevent user tracking might unintentionally interfere with auth, causing third-party cookies or auth tokens to be dropped, and eventually disrupting the authentication process. In a typical frontend auth setup, the authentication process involves the frontend obtaining an auth token or cookie from the backend upon successful login. This token is then used to authenticate subsequent requests. But when the “prevent tracking” option is activated, the frontend may be prevented from storing or sending these tokens or cookies. As a result, the authentication flow is disrupted, and users may find themselves unable to access protected resources or perform authenticated actions. The implications of the “prevent tracking” option on on the authentication flow underline the need for alternative approaches. By moving the auth logic to the backend or adopting other patterns (more on this in a second), developers can mitigate these challenges. So, let’s ditch the frontend and focus on the backend! I mean, it only makes sense right? If implementing the auth flow on the front-end alone makes no sense (and we’ve seen many reasons why that is), then logic dictates we should move it to the back-end. Right? Not exactly. While moving the authentication flow to the backend is a step in the right direction, there is a hidden third option that literally lies in the middle of both alternatives: the Backend-for-frontend, also known as BFF (sounds funny, I know). Let’s review what the BFF pattern is, and why implementing the auth layer in the Backend for Frontend (BFF) makes even more sense! The Power of Backends-for-Frontends (BFF) and WunderGraph The acts as a dedicated mini-backend layer owned by the frontend team, created to cater to the needs of that particular frontend or client. It serves as the only ‘backend’ that frontend app can see, hiding the actual backend from it. This BFF serves as the intermediary between the frontend and the real backend. Backends-for-Frontends (BFF) pattern specifically Think about it this way. Have you ever been part of a project where: The backend wants to develop the services one way and the frontend complains that’s not useful for them? And then each develops and deploys their part independently, having to spend weeks re-adjusting and re-factoring later to sync up and match expectations? One where you have multiple, diverse clients that need to consume the same service (most commonly, when you start offering a mobile app in addition to a web app), leading to complex, chatty (either via overfetching or underfetching) frontend code that results in increased network overhead and slower response times, and becomes harder to maintain and scale? Or simply one where changes in one component had unintended effects on the other, because the frontend and backend were tightly coupled? Who hasn’t right? Well, with the BFF pattern, frontend developers can have more control over the data they need and their interactions with the backend, and each can develop, evolve, and deploy their services independently, without being tightly coupled and stepping on each others’ toes. Check out the following diagram to make more sense of it: The above setup shows a classic client-server setup, while the bottom version shows the BFF pattern being implemented by WunderGraph. Sounds like overengineering, but here’s why BFF is superior to both the frontend and the backend for implementing auth: : Within the BFF, developers can implement various security measures like IP whitelisting/blacklisting, rate limiting, request validation and more. They can use any middleware they want for it and these robust options safeguard backend services from problems like DDoS attacks, ensuring that incoming requests undergo the necessary security checks before reaching your backend. Middleware : The BFF pattern allows developers to add a cache for auth tokens, manage session states efficiently, and aggregate data from multiple downstream backend services. Think about it, you can do anything you want in this layer to save time and avoid unnecessary requests to the actual backend of the application. That of course, translates into a more efficient service and potentially a better user experience. Potential Performance Gains : Auth logic can be iterated upon and scaled independently of the backend, since you’re literally not touching it. This agility helps accelerates development cycles, and ensures resilience as traffic increases through horizontal scaling (adding more servers to the auth-backend). Scalability : With the frontend team also owning the BFF, they can iterate on the user interface and authentication flows independently. Through techniques such as request-mocking, they can move forward with the entire development process while the backend team focuses on developing the core business logic. Granted, eventually both teams will have to “talk to each other”, but this process allows for a safer and more flexible way to work independently from each other. Separation of Concerns for the team : Remember what I said earlier about how a developer with a Dev Console could be a potential problem to a full-frontend implementation? Well, this is one way to solve those problems. With the BFF pattern, developers can’t really see the actual log-in logic, they can only see how the frontend reacts to certain responses and that’s IT. In the end, more than , this is more like , but that was too long to use as a bullet point. Security by obfuscation “security by obfuscation” “security by hiding the logic away from the developer” Alright, by now you should be thinking something like right? “Right, OK, I’m sold, how do I implement my first BFF?” Well, that’s not a trivial task, which is why we’ll use other tools to assist us and help with the process. That’s where WunderGraph comes into play. What is WunderGraph? WunderGraph, the Backend for Frontend (BFF) Framework, streamlines API composition with its intuitive approach. By combining APIs seamlessly and treating them as dependencies, WunderGraph enables developers to build applications that rely on data from multiple sources. With native support for GraphQL Subscriptions and a virtual graph layer for cross-source joins, WunderGraph empowers real-time functionality and simplified data integration. With its open-source nature, WunderGraph aims to make utilizing APIs quick and effortless. You can check out WunderGraph's GitHub . here Let’s Explore Clerk Authentication with WunderGraph in our BFF I always like to say: show me a practical example! So enough with the crazy theory and the list of benefits and let’s get this show on the road. Let’s build something using Wundergraph and the BFF pattern. Actually, we’ll use that AND NextJS as the framework and we’ll also throw in a little bit of to handle the auth process. Clerk STEP 1: Set up WunderGraph + NextJS To get started, let’s set up WunderGraph with NextJS. Open your terminal and run the following commands: npx create-wundergraph-app my-project -E nextjs
cd my-project && npm i && npm start If you see something like this after the first line, it means everything was installed correctly: Verify that everything is working by navigating to in your browser. If you see this (it takes a while, so give it time), then you’re good: localhost:3000 STEP 2: Sign up for a Clerk.com Account To proceed with Clerk, you’ll need to sign up for a account. This will provide the necessary authentication infrastructure for our implementation. Clerk.com Once you’ve signed up, click on “Add Application” and start configuring your authentication strategy. As you can see below, you get a nice preview of your log-in screen (right half of the screen) while at the same time, you can configure which auth methods you’ll allow (left half of the screen): For this example, we’ll just go with e-mail and Google. Now hit “Create Application” and let the SaaS do the rest! You’ll be redirected to a page showing you your new keys and how to configure them on multiple frameworks. The first one is going to be Next and since that’s what we’re using (coincidence?!), just don’t touch anything. Just click on the “copy” button on the top right corner of the keys section (see image below): And save that on your file (if you don’t have one at the root of your project, create one and save the data there). .env You’ll also have to install the package: @clerk/nextjs npm install @clerk/nextjs STEP 3: Implementing Clerk Auth in WunderGraph Now, let’s dive into the code and integrate Clerk authentication into our WunderGraph BFF. For the example, we’ll use the default page that was already created by the generator. We’ll add our auth code, and suddenly we’ll have to sign in to actually see it. First, go to and on the left side menu, select the “JWT Templates” section: Add a new one, and fill in a name, let’s call it “wundergraph” (original, I know), and on the “claims” box, add something like this: Clerk.com {
 "id":  "{{user.id}}",
 "email":  "{{user.primary_email_address}}",
 "company":  "{{user.company}}",
 "lastName":  "{{user.last_name}}",
 "username":  "{{user.username}}",
 "firstName":  "{{user.first_name}}"
} The important bit is you’ll also copy the “JWKS Endpoint”: Then go to and edit the section to look like this: .wundergraph/wundergraph.config.ts authentication authentication: {
  tokenBased: {
    providers: [
      {
        jwksURL: "<the url you just got>",
      },
    ];
  }
} Now go to the file and change it to look like this: pages/_app.tsx import Head from "next/head";
import { AppProps } from "next/app";
import { useAuthMiddleware } from "@wundergraph/nextjs";
import { withWunderGraph } from "../components/generated/nextjs";
import {
  ClerkProvider,
  RedirectToSignIn,
  SignedIn,
  SignedOut,
  useAuth,
} from "@clerk/nextjs";
import { Middleware } from "swr";

export const useWunderGraphClerk: Middleware = (useSWRNext) => {
  const auth = useAuth();

  return useAuthMiddleware(useSWRNext, async () => {
    return auth.getToken({ template: "wundergraph" });
  });
};

function MyApp({ Component, pageProps }: AppProps) {
  return (
    <ClerkProvider {...pageProps}>
      <Head>
        <meta charSet="UTF-8" />
        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
        <script src="https://cdn.tailwindcss.com"></script>
      </Head>
      <main className="flex dark:bg-slate-800 min-h-screen justify-center">
        <SignedIn>
          <Component {...pageProps} />
        </SignedIn>
        <SignedOut>
          <RedirectToSignIn />
        </SignedOut>
      </main>
    </ClerkProvider>
  );
}

export default withWunderGraph(MyApp, {
  use: [useWunderGraphClerk],
}); There are several things to note here: We created the middleware. useWunderGraphClerk We applied the middleware to the exported component. Inside the middleware, we’re referencing the name of the JWT template we created on Clerk (I called it “wundergraph” you might need to change this value if you used another name). I added the component around everything. If you don’t do this, you’ll see an error saying something like . <ClerkProvider> Auth context not found I also added the and components, which take care of adding logic inside the JSX code to understand what to do if the user is signed in or not. SignedIn SignedOut At this point, when visiting you should see a login screen like this: And after logging in, you’ll be redirected automatically to your homepage. http://localhost:3000 STEP 4: But wait, there is more! Yes, you’re done, you can stop reading now, but I wanted to take this a little bit further and show you how cool Clerk is. Inside your logged-in pages, you can add a user menu icon that by default already shows your avatar. And all of that with a single component. Simply add the component inside the file wherever you want and be amazed by the simplicity and power of this component. <UserButton /> pages/index.tsx Here is mine: There you have the “Sign-out” link, which is also a common question users ask after setting everything up! By integrating Clerk authentication into our WunderGraph BFF, we were able to leverage the powerful features and security provided by while benefiting from the simplicity and flexibility of WunderGraph. Clerk.com This is truly a match made in heaven! If you’d like to check out the full source code of this example, , simply clone the repo and go nuts! That said, I hope you found this step-by-step tutorial interesting! I personally loved the simplicity of integration and how both options simplify different aspects of the development process. you have it here In the end, we’re looking at a flexible and powerful frontend capable of being easily integrated into different backends without affecting the UI. Not only that, but we also saw a very simple way of integrating authentication into an existing application with minimum effort! Have you used the BFF pattern before? What about Wundergraph or Clerk? Share your experience in the comments, I’d love to know what you think about this topic!

How to Implement Authentication in Your BFF Architecture in Minutes

Today Vercel and with it their highly requested feature — on-demand Incremental Static Regeneration (ISR)! Many thanks to Vercel for sharing a preview of ISR with us, and featuring us in their announcement post! launched Next.js 12.1 With on-demand ISR you can now build real-time static websites. The websites are dynamic and they change in real time, though they are statically generated in the background. So you get both ultra-fast page loads and global distribution. How does it work, and how does it relate to Six? Read on for more information and a . fun example Special thanks to our awesome customer , for building the examples used in this post! Clerk helps Next.js developers add sign-up, sign-in, and user profile management to their applications in minutes. Clerk What is Svix? Svix is an enterprise-ready webhooks service. Sending webhooks requires a lot of engineering time, resources, and ongoing maintenance. Svix lets you build a state-of-the-art webhooks solution in minutes so you can focus on your business. We power the webhooks for , and we've also recently open-sourced . many amazing companies our webhooks dispatcher What is Incremental Static Regeneration (ISR)? Next.js allows you to create or update static pages after you've built your site. Incremental Static Regeneration (ISR) enables developers and content editors to use static generation on a per-page basis, without needing to rebuild the entire site. With ISR, you can retain the benefits of static while scaling to millions of pages. Static pages can be generated at runtime (on-demand) instead of at build-time with ISR. Using analytics, A/B testing, or other metrics, you are equipped with the flexibility to make your trade-off on build times. Does the above look familiar? It's because it's from the wonderful . Please check them out for more information. Vercel docs What is on-demand ISR? ISR is already great and is used by many companies to drastically improve their build times while retaining incredible performance. However, the current interval-based re-validations have proved insufficient for some use cases. Next.js 12.1 (released today) has introduced on-demand ISR which gives developers the flexibility to manually purge the Next.js cache for a page on-demand. It's exciting for a variety of reasons and uses cases. One thing that it enables that is especially cool is building real dynamic websites with statically generated website performance. You no longer need dynamic routes to have dynamic pages. You can now, in real-time, trigger page rebuilds so that they show the most up-to-date data as it changes. Building the real-time guestbook Webhooks are one of the best ways to trigger on-demand ISRs, so using Svix with on-demand ISR is a natural fit. We are going to build a real-time guestbook. Visitors of this website will be able to signup and create their user profile. The website will then list all of the recently signed-up users (in real-time!). Users will also have their profile page that they can edit and share with others. I know it sounds like a lot because it is. Though using Vercel (deployment), Next.js (On-Demand ISR), Svix (webhooks), and one of our customers, (user profile management and authentication), it's going to be a breeze. Clerk You can try out the and continue reading about how it was built. live example The first step would be to build our website's main UI. We would need a nice description explaining what this website does, a signup button, and a list of users. This is what the code to fetch the list of customers looks like: // pages/index.js

import Head from 'next/head'
import Image from 'next/image'
import { SignUpButton } from '@clerk/nextjs'
import clerk from '@clerk/clerk-sdk-node'

export async function getStaticProps(context) {
  const users = (
    await clerk.users.getUserList({
      orderBy: '-created_at',
      limit: 10,
    })
  ).map((u) => ({
    id: u.id,
    firstName: u.firstName,
    lastName: u.lastName,
    profileImageUrl: u.profileImageUrl,
    createdAt: u.createdAt,
  }))
  return {
    props: { users }, // will be passed to the page component as props
  }
}

export default function Home({ users }) {
  // ...
} Though remember, we haven't added ISR yet, so the list of customers was generated at build time and will remain static until the next build. Let's make it dynamic! The next step would be to implement the new on-demand trigger every time a user signs up. We'll create an API route in our Next.js app to add a webhook receiver: // pages/api/revalidate.js

import { Webhook } from 'svix'
import { buffer } from 'micro'

export const config = {
  api: {
    bodyParser: false,
  },
}

export default async function handler(req, res) {
  // Check for secret to confirm this is a valid request
  const payload = (await buffer(req)).toString()
  const headers = req.headers

  const wh = new Webhook(process.env.SVIX_SECRET)
  let msg
  try {
    msg = wh.verify(payload, headers)
  } catch (err) {
    res.status(500).json({ error: 'Webhook verification failed' })
  }

  try {
    // Rebuild the homepage to update the recent sign ups
    await res.unstable_revalidate('/')
    return res.json({ revalidated: true })
  } catch (err) {
    // If there was an error, Next.js will continue
    // to show the last successfully generated page
    res.status(500).json({ error: 'Revalidation failed' })
  }
} In the code snippet above, we are using the to verify that the webhook was indeed sent from Svix and wasn't maliciously triggered by anyone else. Svix JavaScript library Now we need to trigger it so that the ISR regenerates the page. To do that we'll head over to the Clerk dashboard, and click on the Svix webhooks configuration to add our webhook endpoint. We'll want to set the URL to and listen to the and event types. https://svix-vercel-revalidation.clerk.app/api/revalidate user.created user.deleted We now need to set the environment variable to the secret we get from Svix, and that's it! We've built a real-time statically generated website using Vercel, Next.js, Svix, and Clerk. SVIX_SECRET Let's recap how this whole thing works together. We first build a Next.js application and then deploy it on Vercel. We then go to the Svix section on the Clerk dashboard and add our webhook. With the webhook set, every user creation or deletion on Clerk will trigger a webhook to Vercel, which will in turn trigger the ISR regeneration and rebuild the page. It's that simple! In case you missed it above, you can try it out here: , and view the . https://svix-vercel-revalidation.clerk.app/ source code on Github Closing words We had a lot of fun building this with Vercel and Clerk, and it shows how much you can achieve (and with what performance!) by combining a few cool services. If you want your customers to be able to build workflows and automation on top of your service, like the one you saw in this post, you should . give Svix a try This is it for this update, but make sure to follow us on , , or for the latest updates for the , or join the discussion on . Twitter GitHub RSS Svix webhook service our community Slack Also Published here

Build a Guestbook App Using Next.js ISR Feature and Webhooks

How to Secure User Authentication in React With Clerk

BARCHESTER TOWERS AND THE THREE CLERKS. 1855-1858.

Christian Science by Mark Twain, is part of the HackerNoon Books Series. You can jump to any chapter in this book . TREASURER AND CLERK here TREASURER AND CLERK There are a Treasurer and a Clerk. They are elected by the Board of Directors. That is to say, by Mrs. Eddy. Their terms of office expire on the first Tuesday in June of each year, “or upon the election of their successors.” They must be watchfully obedient and satisfactory to her, or she will elect and install their successors with a suddenness that can be unpleasant to them. It goes without saying that the Treasurer manages the Treasury to suit Mrs. Eddy, and is in fact merely Temporary Deputy Treasurer. Apparently the Clerk has but two duties to perform: to read messages from Mrs. Eddy to First Members assembled in solemn Council, and provide lists of candidates for Church membership. The select body entitled First Members are the aristocracy of the Mother-Church, the Charter Members, the Aborigines, a sort of stylish but unsalaried little College of Cardinals, good for show, but not indispensable. Nobody is indispensable in Mrs. Eddy's empire; she sees to that. When the Pastor Emeritus sends a letter or message to that little Sanhedrin, it is the Clerk's “imperative duty” to read it “at the place and time specified.” Otherwise, the world might come to an end. These are fine, large frills, and remind us of the ways of emperors and such. Such do not use the penny-post, they send a gilded and painted special messenger, and he strides into the Parliament, and business comes to a sudden and solemn and awful stop; and in the impressive hush that follows, the Chief Clerk reads the document. It is his “imperative duty.” If he should neglect it, his official life would end. It is the same with this Mother-Church Clerk; “if he fail to perform this important function of his office,” certain majestic and unshirkable solemnities must follow: a special meeting “shall” be called; a member of the Church “shall” make formal complaint; then the Clerk “shall” be “removed from office.” Complaint is sufficient, no trial is necessary. There is something very sweet and juvenile and innocent and pretty about these little tinsel vanities, these grave apings of monarchical fuss and feathers and ceremony, here on our ostentatiously democratic soil. She is the same lady that we found in the Autobiography, who was so naively vain of all that little ancestral military riffraff that she had dug up and annexed. A person's nature never changes. What it is in childhood, it remains. Under pressure, or a change of interest, it can partially or wholly disappear from sight, and for considerable stretches of time, but nothing can ever permanently modify it, nothing can ever remove it. About HackerNoon Book Series: We bring you the most important technical, scientific, and insightful public domain books. This book is part of the public domain. Mark Twain (2004). Christian Science. Urbana, Illinois: Project Gutenberg. Retrieved October 2022 https://www.gutenberg.org/cache/epub/3187/pg3187-images.html This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever. You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at , located at . www.gutenberg.org https://www.gutenberg.org/policy/license.html

TREASURER AND CLERK

These 12 Open Source Projects Will Leave You Amazed

Advancing the Detection of Ultralight Vector Dark Matter through Novel Analytical Strategies

A Brief History of Money: From the Economy of Favors to Bitcoin

Akshay Rawat’s Innovative Payment Solutions for the Gig Economy

Akshay Rawatın Gig İqtisadiyyatı üçün İnnovativ Ödəniş Həlləri

Akshay Rawat inovativní platební řešení pro koncertní ekonomiku

Soluciones de pago innovadoras de Akshay Rawat para la economía informal

Inovativna rješenja plaćanja Akshaya Rawata za ekonomiju koncerata

Akshay Rawat innovatív fizetési megoldásai a koncertgazdaság számára

Akshay Rawat-ի նորարարական վճարային լուծումները Gig-ի տնտեսության համար

ギグエコノミーのためのアクシャイ・ラワットの革新的な決済ソリューション

Акшай Раваттың концерттік экономикаға арналған инновациялық төлем шешімдері

Innowacyjne rozwiązania płatnicze Akshaya Rawata dla gospodarki gig

Инновационные платежные решения Акшая Равата для экономики свободного заработка

Қарорҳои инноватсионии пардохти Акшай Рават барои иқтисодиёти гиг

Akshay Rawat 为零工经济提供创新支付解决方案

Bitcoinized Fossil Fuel

Биткоинизированное выкапнёвае паліва

Combustible fósil bitcoinizado

Combustible fossile bitcoinisé

דלק מאובן שעבר ביטקוין

ビットコイン化された化石燃料

Bahan Api Fosil Bitcoin

Ibicanwa bya Bitcoin

பிட்காயின் செய்யப்பட்ட புதைபடிவ எரிபொருள்

Сӯзишвории истихроҷи биткоинизатсияшуда

เชื้อเพลิงฟอสซิล Bitcoin

I-Bitcoinized Fossil Fuel

Stories, News & Mentions about CLERK

Clerk’s Stories on HackerNoon

Clerk's News & Mentions