Forem: Nick

The Hidden AI Cheating Crisis Costing Companies $125,000 Per Bad Hire

Nick — Mon, 26 May 2025 00:46:17 +0000

The Hidden AI Cheating Crisis Costing Companies $125,000 Per Bad Hire

How Cluely AI and Similar Tools Are Undermining Your Remote Interview Process

A comprehensive guide for HR professionals on detecting and preventing AI-powered interview fraud

https://www.detectcluely.com/

Last month, Sarah, a seasoned HR director at a Fortune 500 company, thought she'd found the perfect candidate. The remote interview was flawless—every technical question answered with precision, behavioral responses that hit every STAR method point perfectly. Two weeks into the job, it became clear: this person couldn't perform even basic tasks they'd demonstrated mastery of during the interview.

Sarah's company had fallen victim to AI-powered interview cheating.

The $125,000 Problem No One's Talking About

While companies have invested millions in sophisticated ATS systems and interview processes, a new threat has emerged that's flying completely under the radar. Tools like Cluely AI are giving candidates real-time answers during video interviews, and the financial impact is staggering:

$85,000 average cost in salary and benefits for one bad hire
$15,000 in training and onboarding expenses
$25,000 in lost productivity and team disruption
Total cost per fraudulent hire: $125,000

And here's the alarming part: 73% of HR professionals have never heard of AI interview assistance tools, according to recent industry surveys.

How AI Interview Cheating Actually Works

Modern AI cheating tools like Cluely operate through sophisticated screen-monitoring technology:

Real-time audio processing: The AI listens to interview questions as they're asked
Instant answer generation: Advanced language models provide detailed, role-specific responses
Seamless delivery: Answers appear on secondary screens or through discrete notifications
Behavior coaching: Some tools even provide real-time coaching on body language and tone

The technology has become so advanced that even experienced interviewers struggle to detect when it's being used.

Red Flags Every HR Professional Should Know

Technical Interview Red Flags:

Perfect answers with no thinking time: Immediate, comprehensive responses to complex technical questions
Robotic response patterns: Answers that sound like they came from documentation rather than experience
Inability to elaborate: When asked to expand on answers, candidates struggle or repeat the same information
Screen-looking behavior: Frequent glances away from the camera, especially to secondary monitors

Behavioral Interview Red Flags:

STAR method perfection: Every behavioral question answered with textbook-perfect structure
Generic examples: Stories that sound like they could apply to anyone in any role
Inconsistent details: When asked follow-up questions about their examples, details don't align
Unusual confidence: Candidates who seem overly prepared for every possible question

The Detection Challenge

The most concerning aspect of this trend is how difficult detection has become. Unlike traditional cheating methods, AI-powered assistance creates responses that are:

Contextually appropriate: Answers are tailored to the specific role and company
Naturally phrased: Advanced language models generate human-like responses
Technically accurate: AI can access vast databases of information instantly
Behaviorally appropriate: Some tools even coach candidates on interview best practices

Protecting Your Organization: A Strategic Approach

Immediate Actions:

Educate your interview team about AI cheating tools and detection methods
Implement multi-stage verification with practical assessments that can't be easily assisted
Use randomized questioning that makes it harder for AI to prepare responses
Require camera-on policies with specific positioning requirements

Long-term Solutions:

Invest in detection technology that can identify unusual patterns in candidate behavior
Develop role-specific practical assessments that require real-time problem-solving
Create collaborative interview formats that are harder to cheat on
Establish clear policies regarding AI assistance in interviews

The Legal and Ethical Implications

As AI interview cheating becomes more prevalent, organizations need to consider:

Fair hiring practices: How do you maintain equity when some candidates have AI assistance?
Legal compliance: What constitutes fraud in the interview process?
Policy development: Clear guidelines on acceptable and unacceptable AI use
Documentation requirements: Proper record-keeping for potential legal challenges

Industry Response and Future Outlook

Leading HR technology companies are beginning to develop counter-measures, but the cat-and-mouse game between cheating tools and detection systems is just beginning. Organizations that don't adapt their interview processes risk:

Decreased hiring quality: More unqualified candidates slipping through
Increased turnover costs: Bad hires leading to quick departures
Team disruption: Unqualified team members affecting overall productivity
Reputation damage: Poor hiring decisions reflecting on HR effectiveness

Taking Action: Your Next Steps

The AI interview cheating crisis requires immediate attention from HR leaders. Here's what you can do today:

Assess your current vulnerability: Review your remote interview processes for potential weaknesses
Train your team: Educate interviewers on detection methods and red flags
Update your processes: Implement practical assessments and verification steps
Invest in detection tools: Consider technology solutions that can help identify AI assistance

Conclusion: The Time to Act is Now

The emergence of AI-powered interview cheating represents a fundamental shift in the hiring landscape. Organizations that recognize this threat early and adapt their processes accordingly will maintain their competitive advantage in talent acquisition.

Those that don't may find themselves paying the $125,000 price tag—repeatedly.

The question isn't whether AI interview cheating will affect your organization. The question is whether you'll be prepared when it does.

Want to learn more about protecting your organization from AI interview fraud? Visit DetectCluely.com for comprehensive detection guides and tools designed specifically for HR professionals.

About the Author: This article was written by industry experts specializing in HR technology and interview security. For more insights on modern hiring challenges, follow our publication.

HumanResources #InterviewFraud #ArtificialIntelligence #RemoteWork #HiringBestPractices #TalentAcquisition #WorkplaceTechnology #InterviewSecurity #HRTechnology #RecruitmentFraud

[Boost]

Nick — Sun, 15 Dec 2024 05:43:54 +0000

Deploying Next.js + Pocketbase to a single Fly.io machine

Nick ・ Dec 15

#webdev #startup #programming #typescript

Deploying Next.js + Pocketbase to a single Fly.io machine

Nick — Sun, 15 Dec 2024 04:08:23 +0000

I am constantly starting side projects, and like so many, I try to get the product out the door as quick as possible. I previously thought I have touched nirvana with Next.js + Supabase, but after so many projects you have to start paying Supabase the big bucks!

After two projects you need to pay Supabase 25 dollars a month, and each project you add is an additional 10 dollars a month. Pricey for side projects that are yet to make any money.

nicholasoxford / pocketwatcher

🚀 Production-ready Next.js template with PocketBase and shadcn/ui. Includes authentication, beautiful UI components, and one-command deployment.

PocketWatcher

Overview

A modern full-stack template that combines the power of Next.js, the simplicity of PocketBase, and the beauty of shadcn/ui. Perfect for quickly bootstrapping production-ready web applications with authentication and a polished UI.

Features

🚀 Next.js 15+ App Router
📦 PocketBase backend with built-in authentication
🎨 Beautiful UI components from shadcn/ui
🌐 Server-side rendering and client-side interactivity
🔄 Form handling with React Server Actions
🔐 Complete authentication system with email/password
🐳 Production-ready Docker setup
☁️ One-command deployment to Fly.io
🔒 Secure cookie-based authentication
🛡️ Type-safe development with TypeScript
⚡ Bun for fast package management and running scripts

Getting Started

Prerequisites

Bun runtime
Fly.io CLI (for deployment)

Local Development

Clone the repository:

git clone https://github.com/yourusername/pocketwatcher.git
cd pocketwatcher

Install dependencies:

bun install

Start the development servers:

In one terminal, start PocketBase:

./pocketbase serve

In another terminal, start the Next.js development server:

bun run dev

Access the applications
- Next.js: http://localhost:3000
- PocketBase Admin…

View on GitHub

I was deploying so many Supabase projects I created a cli to self host Supabase on fly.io, Supafly

Side projects live and die by annoying blockers, the things that are getting in your way that shouldn't. After 10, 15, 20 or so side projects you might start to get a feel for what platform to reach for when.

What if we could host our entire app, in a familiar fashion, on one machine? Our database, API, and frontend. We should also be able to host this and have easy local development. Local development is classically a bit annoying with Supabase.

This gives you Authentication, a SQLite database (based), a self deploy next.js app, which is also your api layer, and the ability to do file upload + email easily.

Deploying Your Stack to fly.io

Getting your app live is surprisingly straightforward. Unlike traditional deployments where you're juggling multiple services, this is all handled in one go.
First-Time Setup

Install the Fly.io CLI if you haven't already

curl -L https://fly.io/install.sh | sh
fly auth login

The Launch Process

bun run launch

When you run this, you'll hit two prompts:

"Do you want to tweak these settings before proceeding?"
→ Just hit enter (the defaults work great)
"Would you like to allocate dedicated ipv4 and ipv6 addresses now?"
→ Type Y (you'll need this)

Getting Your Admin Access

Here's the crucial part that often trips people up. Your PocketBase admin setup needs a special URL, but it's easy to find:

fly logs | grep pbinstal
This will show you something like:
Copyhttp://0.0.0.0:8090/api/admins/confirm-password-reset?token=YOUR_TOKEN_HERE

"Important: Modifying the URL"
You'll need to change this URL before using it:

Replace http://0.0.0.0:8090 with https://your-app-name.fly.dev:8091
Keep the rest of the URL path and token exactly the same

Once you're set up, you can access your app at:

Main App: https://your-app-name.fly.dev
Admin Panel: https://your-app-name.fly.dev:8091/_/

Pro Tips
"Deployment Troubleshooting"

If you don't see the pbinstal log right away, wait a minute and try the logs command again
Keep that initial admin URL safe until you've set up your account
Once you've set up your admin account, that initial URL won't work anymore (this is a security feature)

Check out more of my writing at nicholasoxford.com

Project made with this: domainbobber.com

Minting a tree for compressed NFTs

Nick — Thu, 23 Mar 2023 15:15:48 +0000

If you are still NFT Twitter adjacent, you've seen a firehouse of tweets about compressed NFTs. Just like with Candy Machine V1, they are all the rage. Today we are focused on step one of minting a compressed NFT, minting a tree on-chain.

I've found a few great explanations on what compressed NFTs are:

Alchemy's: What are compressed NFTs?

Metaplex's: Expanding Digital Assets with Compression for NFTs

The main goal of compressed NFTs is to dramatically decrease the cost of minting to greatly widen the adoption of Solana NFTs.

When working with toy Solana projects, I've found that using a Next.js app is the best way to get started quickly. In my experience, you need a node server to work with Metaplex code. With the api folder, you can get a lot done without having to worry about compatibility and code splitting.

Getting started

We need to install relevant dependencies

npm install @solana/spl-account-compression @solana/web3.js @metaplex-foundation/mpl-bubblegum @mintee/wrapped-connection

The first part of working with compressed NFTs is familiarizing yourself with the connection wrapper. If you follow any example, you will see that it extends the normal @solana/web3.js Connection class with some helpers around Keypairs and compressed NFTs. You pass in your RPC URL and a keypair to sign/pay for transactions.

import WrappedConnection from "@mintee/wrapped-connection"
import {
  Keypair,
  PublicKey,
  SystemProgram,
  Transaction,
  sendAndConfirmTransaction,
} from "@solana/web3.js";


const keypair = new Keypair()
const connectionWrapper = WrappedConnection.getConnectionWrapper("https://api.mainnet-beta.solana.com", keypair);

We are going to define a function called mintTree(). When minting an account to hold your tree, you need to define the depth and buffer size. 2^{DEPTH} is the capacity of the tree.

When working with Solana, you have to calculate how large the account size needs to be upfront. When working with compressed NFTs, you have a higher up-front cost, but each mint is cheaper.

export async function mintTree() {
  const payer = connectionWrapper.payer.publicKey;
  const treeKeypair = new Keypair();


  const maxDepth = 14
  const maxBufferSize = 64

// create account size based on number of NFTs
  const space = getConcurrentMerkleTreeAccountSize(maxDepth, maxBufferSize);
// get tree authority 
  const [treeAuthority, _bump] = await PublicKey.findProgramAddressSync(
    [treeKeypair.publicKey.toBuffer()],
    BUBBLEGUM_PROGRAM_ID
  );

Now that we have created the instructions for minting an account we need to write the transactions for allocating the account and creating the tree.

const createTreeIx = createCreateTreeInstruction(
    {
      merkleTree: treeKeypair.publicKey,
      treeAuthority,
      treeCreator: payer,
      payer,
      logWrapper: SPL_NOOP_PROGRAM_ID,
      compressionProgram: SPL_ACCOUNT_COMPRESSION_PROGRAM_ID,
    },
    {
      maxBufferSize,
      maxDepth,
      public: false,
    },
    BUBBLEGUM_PROGRAM_ID
  );


  let tx = new Transaction().add(allocTreeIx).add(createTreeIx);
  tx.feePayer = payer;

After sending the transaction we will get back an assetId. The assetId is a PDA of Bubblegum. It the equivalent of a token address. This is where compressed NFTs get controversial. They are a pretty unique RPC extension, so if you mint a compressed NFT on Helius per se, you have to use that RPC to get back the info.

try {
    await sendAndConfirmTransaction(
      connectionWrapper,
      tx,
      [treeKeypair, connectionWrapper.payer],
      {
        commitment: "confirmed",
        skipPreflight: true,
      }
    );

    console.log(
      "Successfull created merkle tree for account: " + treeKeypair.publicKey
    );

    return treeKeypair.publicKey;


  } catch (e) {
    console.error("Failed to create merkle tree: ", e);
    throw e;
  }
}

Using Python to track NFT prices on FTX

Nick — Sat, 30 Oct 2021 14:49:30 +0000

Recently during the launch of ChickenTribe on the Solana blockchain, I became intrigued by a certain NFT. If you watch TV or don't have adblocker you've probably seen ads for FTX everywhere. FTX, in my opinion, is the premier trading platform for cryptocurrencies. I prefer it to coinbase and I think its relevance will only grow. They just completed a fundraising round for $420 million dollar from 69 investors.

During this time, ChickenTribe #0 was listed for sale, but returned an error when I clicked purchase. I thought, let me try to create an api to ping this until it's able to sell and buy it programmatically. What I was surprised by was just how easy it is to call FTX via its API and act on the data you receive.

To get info about a particular NFT all we need to do is write and run this python program:

import requests
import json
while True:
    try:
        data = requests.get('https://ftx.us/api/nft/nft/485223445421518089').json()      
        result = data['result']
        result_formatted = json.dumps(result, indent=2)
        print(result_formatted)
        break
    except Exception as e:
        print(f'Error obtaining NFT data: {e}')

This returns:

{
  "id": "485223445421518089",
  "name": "ChickenTribe #0",
  "description": null,
  "issuer": "ChickenTribe",
  "collection": "ChickenTribe",
  "series": "ChickenTribe",
  "solMintAddress": "Du7roiVM8VzX6GFiQLYePcp1fLnkDhxWdFeQN4GMpAQF",
  "ethContractAddress": null,
  "imageUrl": "https://www.arweave.net/FnSVZj95IP0uYpU0mcHVr3TPUvCewxwTNgCQ1Ff6Xjc?ext=png",
  "videoUrl": null,
  "animationUrl": null,
  "thumbnailUrl": null,
  "attributes": {
    "Backgrounds": "Rust Red",
    "Bodies": "Fall",
    "Heads": "Ruby",
    "Faces": "Lava",
    "Combs": "Basic Purple",
    "Eyes": "None",
    "Accessories": "None",
    "Smokes": "None"
  },
  "attributesList": [
    {
      "value": "Rust Red",
      "trait_type": "Backgrounds"
    },
  ],
  "number": "0",
  "totalQuantity": null,
  "redeemable": false,
  "redeemed": false,
  "offerPrice": null,
  "donation": false,
  "status": "approved",
  "needsListingFee": false,
  "featured": false,
  "created_at": "2021-10-29T15:42:44.431599+00:00",
  "createdAt": "2021-10-29T15:42:44.431599+00:00",
  "quoteCurrency": "SOL",
  "auction": null,
  "depositMethods": [],
  "withdrawalMethods": [
    "sol"
  ],
  "totalSellerFeeRate": 0.07,
  "royaltyFeeRate": 0.05
}

While nft/nft/{$id} might be confusing at first. To grab all nfts you would simply call nft/nfts and iterate through the result.

while True:
    try:
        data = requests.get('https://ftx.us/api/nft/nfts').json()      
        result = data['result']
        for nft in result:
          result_formatted = json.dumps(nft, indent=2)
          print(result_formatted)
        break
    except Exception as e:
        print(f'Error obtaining NFT data: {e}')

If you have never run python code on your computer I recommend Google Collab. Here is a link to a worksheet with the above code. You need to run each cell individually, in order.

Sign up for FTX Here

Let me know what you would like to see in future tutorials. Next tutorial I will be covering authentication to act on the data we retrieved.

If you found this helpful, consider sending a tip to the author. 
2vta8S9QJEeZSRTXxR5eL3tfpFVbHhRAKMnQmQeCBKAV

Deploying Your First Arweave Contract

Nick — Sat, 30 Oct 2021 13:41:40 +0000

At a high level, smart contracts make sense to a lot of people. They are programs that live on chain, that are deterministic in nature, and are based in that idea code is law. I first learned about smart contracts back in 2017 with ethereum first gaining traction. Instantly my mind wandered into ideas of these interweaving contracts that mitigate the need for lawyers. I think the most important thing to remember about smart contracts is that they are supposed to remove a human element, which all programs typically try to do, but do it in a verifiable and reproducible way... All on the ✨ Blockchain ✨

Arweave released their version of smart contracts back in June 2020. Smartweave, or a new smart contract protocol, enabling computation-heavy dapps on top of the Arweave network, allowed devs to write some simple javascript and easily deploy it to the chain. If this is your first time learning about Arweave, I recommend checking out my introduction. If you're familiar with the ecosystem, you will notice that Smartweave is built upon the foundation of the blockweave. Unlike Eth v1 implementation of smart contracts, where each node has to validate the outcome - smartweave deploys a lazy evaluation method. Where Arweave's "network is utilized as a generic data consensus and sharing layer". Basically, the user broadcasts the outcome of their smart contract and the network validates. Learn more here

In a later post, I will dive deeper into the background of smartweave and its technical implementation.

First, let's go ahead and create a contract.js and a contract.json in the folder of your choice. Smartweave uses javascript through the client's unmodified execution engine. What I have found the biggest mental switch is that you don't define variables in the .js file. You define the name and initial state of each relevant variable in .json.

The first bit of code we are going to write is our javascript. Something important to remember is that contracts must be deterministic. I feel like deterministic is one of those signal words CS major use to beckon each other. All it means is that the function will produce the same output from a given starting input. You should never do a network call or produce a random number inside of a smartweave contract. Lastly, we can arbitrarily (up to a certain number of bites) input any data when we call our contract. We pass in these inputs via action.input.function === 'someString'.

export function handle(state, action){
if (action.input.function === 'Twitter') {
    state.twitter = true;
  }
  if (action.input.function === 'ArWallet') {
    state.arWallet = true;
  }

  if (action.input.function === 'arVerify') {
    state.arVerify = true
  }
  if (state.twitter && state.arVerify && wallet) {
    state.mintNft = true;
  }
  return mintNFt; 
}

You'll notice we have a bunch of variables passed in through the state variables. These are the variables defined in your json.

{
  "twitter": false,
  "arWallet": false,
  "arVerify": false,
  "mintNft": false
}

This contract was created while I was working on another Arweave project where if you complete a certain number of steps you will receive a free NFT. More on that at a later date. This contract will get called when a user connects their wallet. At that time I will pass in arWallet: true. This contract will continue to return false until all three variables are set to true. In the next article when we interact with our contract, you'll see how we can retrieve state without an input. What's cool is that contracts can read the state of other contracts.

Let's go ahead and check if we have a key-file representing our Arweave wallet. While you don't need gas to interact with a contract you do to deploy, although it's nominal. Luckily you can get a dollar or two of AR through the faucet.

I'll be honest, when I was getting ready to deploy my first the README.md was confusing me. It wasn't until I ran smartweave create -h in my terminal didn't I really understand what I needed to pass in. To deploy our contract you need to have Node install and run npm install -g smartweave. This globally installs the smartweave package so we can call it anywhere. Next, navigate to the folder your contracts are in and remember where your key file is.

smartweave create -h
  ____                       _ __        __
 / ___| _ __ ___   __ _ _ __| |\ \      / ___  __ ___   _____
 \___ \| '_ ` _ \ / _` | '__| __\ \ /\ / / _ \/ _` \ \ / / _ \
  ___) | | | | | | (_| | |  | |_ \ V  V |  __| (_| |\ V |  __/
 |____/|_| |_| |_|\__,_|_|   \__| \_/\_/ \___|\__,_| \_/ \___|

smartweave create <contractSource> <initStateFile>

Creates a new contract from a source file or existing contract source already
on-chain.

Positionals:
  contractSource  The contract source. A path to a .js file, or transaction id
                                                                      [required]
  initStateFile   The initial state of the contract. Path to a .json file
                                                                      [required]

Options:
  --version   Show version number                                      [boolean]
  --help      Show help                                                [boolean]
  --key-file  Your key file                                           [required]

Looking at the -h you see the create call is really quite simple. Just pass in the path to your js and json file in that order. Last declare your key pair with --key-file. When you click enter the network will first calculate your tx fee. After this is calculated it will ask you to enter a random adjective it generated.

The contract will get pushed to the network pretty quickly. However, it will take a while for your transaction (tx) to be mined. Tx are prioritized by their fee amount. I use https://arweave.app/ to check my pending transactions.

In the next smartweave tutorial we will look at our wallet transaction history, interact with our wallet using the command line, and through a web application.

If you found this helpful (AR Wallet):
WtrURL9vjAUQQXMQxY5c9FZnh_IKOog5P38KO7oZnbg

Getting Started With Arweave

Nick — Thu, 28 Oct 2021 20:37:40 +0000

Our entire life, we have been told what we post on the internet lives forever. While this might be true for that photo you're embarrassed of, generally, the data that existed on the internet when we were younger, is gone. We currently depend on a slew of companies to store and access our data. What's crazy is the vast majority of us have never given a dollar to Google or Facebook. Yet their trillion-dollar valuations make them some of the most valuable companies of all time. While during my life I have benefited from the network effects these platforms created, and I can currently look back on the majority of my life through Facebook memories, something isn't right with leaving our footprint to these technology behemoths with cartel-like behavior over YOUR data. Web 2.0 is unsustainable - and why would you want it to be?

I think for a lot of people, creating a sort of digital footprint, one future generation can look back on, is starting to bubble up in one's mind. With the current state of the web, we aren't choosing what sticks around. I already regret a whole slew of Instagram photos I deleted back when I was younger. I basically erased a good part of my digital past. There has to be a better way to pass on these important digital memories. Really, if Facebook is still relevant when my great-grandkids are around - God helps us all.

Arweave is such a perspective shifter, that I think naturally we kinda shrug it off. Permanent data storage -- sure. Oh and on top of a blockchain?? okay my guy! Yet, the further I dig into Arweave the more I am convinced. I think the crucial part of Arweave is that for a miner to receive a reward - not only do they have to mine (store) the new data from the Blockweave on their hardware, they also have to return a random document that the network demands. With the right incentive structure, you can encourage the right parties, to store data forever. Obviously, I am simplifying the array of protocols that made something like Arweave possible, but the cool thing is to interact with Arweave and permastorage you really don't need to understand what is going on. This will also become easier over time, using ArDrive it can already feel like uploading a file to Dropbox.

You might know Arweave through Metaplex - or the Solana defacto standard for creating NFTs. When creating these NFT's, what is actually happening is that each image is being uploaded to Arweave, and the corresponding URL is appended to that particular tokens metadata.

The coolest thing is that Arweave is more than just simple data storage and retrieval protocol. Which is fast by the way. It is a platform to ensure memories, perspectives, and data can be put into the record, permanently. Personally, I've never had an issue with being censored. I've been lucky enough my whole life to share my opinions freely, without any repercussions or take-backs. This is clearly not true for everyone. Arweave allows us to upload data now, and judge later.

Beyond images, you can upload entire web applications, smart contracts, and other forms of multimedia that will still the same - forever. What's interesting is that when you upload a website or web application, you have to think differently. This as is, will be the way it is forever. That is exciting! Who knows who will interact with my website, decades from now. This is a byproduct of the immutability of Arweave. Each block of data is cryptographically intertwined with the previous and following block. Lastly the economic model is what makes it sustainable. To upload an image it cost about 2 cents. This is both paying to upload the image immediately and then some of that transaction is going into an endowment. Because storage gets cheaper over year the relatively purchasing power of that endowment goes up. Effectively acting like interest.

Arweave isn't something we can learn in a day, or a simple article. It's a journey that connects deeply with you. What does permanent mean to you? What do you want to leave behind. Do you want to help a certain group digitize their history? This is just the beginning of a deep exploration of Arweave. In the next article, I will be deploying a website to the permaweb. You won't believe how easy it is.

Permaweb Pioneer's Podcast

If you found this helpful (AR Wallet):
WtrURL9vjAUQQXMQxY5c9FZnh_IKOog5P38KO7oZnbg

Getting started with Metaplex (A Solana NFT Journey PT. 1)

Nick — Sun, 26 Sep 2021 19:04:00 +0000

TLDR

Ignition Metaplex Worskshop
Zoom Office Hours / PW: I5T$pa^z
End to end Candy Machine Tutorial by Noah Hein
Levi Cook's OG and continually updated Candy Machine guide
Ignore my original candy machine guide and use ts-node

The velocity and excitement around the Metaplex ecosystem keeps me coming back every day. I feel both a desire and reward to learn more. I would be lying if I said I had it all figured it. I mean I already wrote one guide on using Metaplex's candy machine, but in my eyes, it's already out of date! It's not like the NFT's I minted with that tutorial are invalid, there are just more robust ways to get your 5000 pngs on the chain.

If you are interested in Metaplex, I would recommend two things. First, watch Metaplex's Ignition Workshop. Ignition is the Solana hackathon currently happening (var today = September 27th, 2021) until October 15th. There are 4 tracks, over 5 million dollars in awards, and sponsors like Microsoft, Metaplex, and Mango. The other content I would watch, as of today, is Metaplex's office hours from Friday. So many nuggets of knowledge to be had, and I know I will be attending them from here on out.

Meeting Recording:
https://solanalabs.zoom.us/rec/share/5azT9d0TACBbGPxVV0Js1FocnoAJ6cOK1CYVsl_EyAGP8opJxa-unbtO6X7aTitn.81Xk1R8XO-mSWRVi

Access Passcode: I5T$pa^z

After watching the office hours, I knew immediately that my tutorial was at best, out of date. This could be a point of pain, thinking why did I write this, but honestly - I find it exciting. When things change, you look for a source of truth, when you find that source of truth, changes aren't so bad. The source of truth for Metaplex's candy machine is candy-machine-cli.ts

If we go to this file on GitHub, and cmd-f create_candy_machine. You will see a code representation of what returns when you entered metaplex create_candy_machine -h:

Usage: cli create_candy_machine [options]

Options:
  -e, --env <string>                Solana cluster env name (default: "devnet")
  -k, --keypair <path>              Solana wallet location (default: "--keypair
                                    not provided")
  -l, --log-level <string>          log level
  -c, --cache-name <string>         Cache file name (default: "temp")
  -p, --price <string>              Price denominated in SOL or spl-token
                                    override (default: "1")
  -t, --spl-token <string>          SPL token used to price NFT mint. To use
                                    SOL leave this empty.
  -t, --spl-token-account <string>  SPL token account that receives mint
                                    payments. Only required if spl-token is
                                    specified.
  -h, --help                        display help for command

You might notice that command-line options like --log-level aren't listed under create_candy_machine. That's because these are global options defined inside the function programCommand on line 611. Did you know, in VsCode you can hit control+g on mac to jump to a line, neat!

Whenever I see people ask on the Metaplex discord if something is possible, they should just look at this file. It also contains the definition for updating a candy machine. What I find interesting is that the code follows a pretty simple flow, especially for update_candy_machine. If you watch deep into the Metaplex ignition workshop, the presenters discuss how simple candy machine actually is.

I believe this simplicity is difficult to see when you are first starting out. I read the Metaplex docs a couple times before it started to click. It's not like I read it end to end each time, but the mental model took a few days to come together. Y'all are brighter than me though.

Beyond just Levi Cook's legendary tutorial, I have found that Noah Hein's How to Mint an NFT on Solana Using Candy Machine to be the most comprehensive tutorial out there. I'm probably going to update my old tutorial to only point to this site.

If you have been following Levi's guide, you know at one point you used the metaplex command line binary to create candy machines. This is currently not recommended. Believe me when I say it wasn't pleasant to install anyways.

Don't use the metaplex binary to create a candy machine

In both the workshop and more specifically the zoom call around 15:30 they talk and show how to create a candy machine by calling the typescript files directly. Make no mistake, you will still be using the command line, just not the metaplex package. At least for the time being.

That moment when everything clicks

When I was first working with the candy machine, I wasn't aware of the significance of what the Metaplex foundation is making. I highly recommend going to js/packages/web and running the web app. Once you connect this next.js app to your wallet, you are able to mint individual NFTs, dictate the way they are sold, and auction them off all on a deployable web UI. Now I am a full time Vue software engineer, so when I see React I typically look the other way. However, it's clear that React is the way to go here. I know enough about React to see the amount of work that has gone into connecting Solana wallets and React hooks. I do not want to rewrite that in Vue (alone). I found the candy-machine originally from an Exiled Apes github repo. If you are familiar with the Exiled Ape's candy-machine repo, it seems to be more just a drop in wallet for any react app. The metaplex web folder comes with all the tools you need to launch a full NFT site. It is a little slow, so a take a breath, and just enjoy the learning.

exiled-apes / candy-machine-mint

Fork, config, customize and ship your own candy machine mint app on your own domain, ultra fast.

Candy-Machine-Mint

The Candy-Machine-Mint project is designed to let users fork, customize, and deploy their own candy machine mint app to a custom domain, ultra fast.

A candy machine is an on-chain Solana program (or smart contract) for managing fair mint. Fair mints:

Start and finish at the same time for everyone.
Won't accept your funds if they're out of NFTs to sell.

The Candy-Machine-Mint project is meant to be as simple and usable as possible, accessible to everyone from long-time crypto devs to junior React devs with a vague interest in NFTs. Our goal is to empower users to create their own front ends to display, sell, and manage their NFTs as simply as possible by just updating a few styled components and following a well-documented process for setup and shipping.

Getting Set Up

Prerequisites

Ensure you have recent versions of both node and yarn installed.
Follow the instructions here…

View on GitHub

Okay cool, with this Metaplex platform we can be an artist on the lower end of technical expertise all the way to an experienced rust developer connecting metaplex contracts with anchor programs using CPIs!

I have a strong feeling that this is just the beginning of Metaplex. For artist and developers alike, types like seller_fee_basis_points make for a healthier eco system. Metaplex also pushes the community towards good actors, or at least exposing potential bad actors. An nft marketplace does not need to enforce royalties, but the community would put them on blast the second anyone finds out.

Conclusion

If you used my first tutorial, ignore it, and use the:

ts-node ~/metaplex-foundation/metaplex/js/packages/cli/src/candy-machine-cli.ts

method instead. I'm sure in a week I will need to post another update with all the great changes multiple teams are making.

In part 2 I will continue to showcase the metaplex platform and begin to explore Arweave. Let me know if you would like an article giving an overview of Solana as well! I hope you all feel the excitement I feel when I am truly learning hour after hour. I know I am not going to get this rust code overnight, I know I am not going to get every detail right about my first candy machine. The important part is we both keep coming back night after night.

Nicholas Oxford

If you found this helpful, consider sending a tip to the author.
2vta8S9QJEeZSRTXxR5eL3tfpFVbHhRAKMnQmQeCBKAV

Going Serverless with MongoDB Realm & Vue 3

Nick — Mon, 20 Sep 2021 22:06:52 +0000

MongoDB Atlas is a comprehensive platform for building data driven applications. While most people know Mongo for their document style database, the capabilities of their cloud platform can empower both individual developers and teams to do great things - fast. When you spin up an Atlas cluster, you have search, charting, and data archiving built in. Today, I'll be walking through getting started with MongoDB's serverless solution - Realm

Realm originally was an open source, object database oriented towards the mobile market and developer experience. They made it easy to sync data between clients(phones and tablets) and a central database. However, today it is a platform that:

builds better apps faster with edge-to-cloud sync and fully managed backend services including triggers, functions, and GraphQL.

The fact that Realm sits right on top of your database means you can easily stand up an API with authentication in minutes. It automates many parts of creating an API, - it creates the GraphQL schema, runs a validation, and helps you craft your queries through custom resolvers and mutations.

Beyond just GraphQL, Realm can also host a single page application or static sites, run serverless functions, and perform magic with Sync. If you do it right, your entire stack can be on Atlas. We're going to create a web app to do just that.

I really like the idea of visualizing data on a map. While I made a tutorial about doing this in Python, I love creating things for the web. Everyone is always app this, app that, but this limits your audience to a single platform - unlike the web. Billions of people have access to an internet browser. Let's build a website that calls our data and visualizes it on a map.

Seems pretty simple, but the second you have your site call a database it can go from some fun project to teeth grinding code writing, where you forgot why you were even doing this in the first place. I think keeping the fire alive is what can take a project from some weeknight thing to a passion project you continue to iterate on.

If you are interested in seeing me upload crime data to a MongoDB collection, I am happy to walk through that - just let me know. However, for this project, we will be using the sample data that comes with MongoDB. If you have done a MongoDB tutorial you will be beyond familiar with these sample collections.

The sample database we are going to use is called sample_geospatial, which is a collection of 11,000 shipwrecks. MongoDB actually allows you to do GeoSpatial queries, like $geoNear - which returns an ordered stream of documents based on the proximity to a geospatial point. Real quickly, a MongoDB instance, or cluster, is made up of Databases that contain collections. Unlike SQL, it is document-based, rather than relation-based. The document style is really suitable for information related to web applications. You can load everything you need for a page without joining tables. You just have to architect it right.

Creating The Database 💾

If you haven't yet, go ahead and create a MongoDB account. Besides AWS, the MongoDB free tier is as generous as they come. After creating a project and a database, click [...] - Load Sample Data:

If you now click Browse Collections you will find our geospatial database + the single shipwrecks collection. If we click through to this and see the list of documents, we can get an understanding of the general shape of the document.

My hunch is we will mainly be focused on longitude and latitude. I recommend clicking through a few pages of documents and get a mental model of what you are seeing. Now that we have looked at our data, let's go ahead and click the Realm Tab at the top of the page. If you haven't created a Realm project before you will see the following dialogue. Name the app whatever your heart desires and navigate to the schema tab.

After clicking this tab, it prompts us to add a Data Source. Make sure to chose your cluster, probably named Cluser0. Now name your Realm project, I am going with data-viz. I am going to leave MongoDB Connection string off for now. Finally chose primary for the Read Preference and click Save Draft.

With Realm, deploying changes is a two-step process. We just drafted our changes - which at the end of the day are just a few line changes in a few config.json files - now we need to deploy them. You will see a blue banner with a button about review and deploying. Click through.

Before we can create a schema based on our data we have to give Realm permission to our shipwrecks collection. Click "+ Add Collection" on the Rules page it just directed you too. Make sure to select the geospatial database and proper collection. If you don't see any databases or collections, your cluster might be performing maintenance. If you go back to the Atlas tab, you can see if your cluster is ready or not.

Once the collection shows up, click Shipwrecks. Ignore the sections about permissions and templates and click Add Collection in the bottom right.

Now if we go back to the schema page we can generate the GraphQL schema. You'll see a green "Generate Schema" button on the right side of the page. Click it.

Make sure to chose just the shipwrecks collection in the first select. Next, you choose how many documents to sample. With GraphQL, the schema validation matters in totality. It feels like an iron first that forces you to get your data structure down. 500 is fine for this. I've found major diminishing marginal returns after around 750.

Click save and deploy. Without saving and deploying, your validation won’t work. When we navigate to the validate tab, and click run, it should pass!

We are off to a great start, though it might feel like we've done nothing - but understanding what the heck is going on will have you feeling more confident when we start coding the frontend.

Click GraphQL in the left-hand menu, and click play in their interactive frame. It should return a single shipwreck. If we remove fields like history and recrd then rerun the document you will see that our response does not include those fields. This is the beauty of GraphQL, we only get back the fields we ask for! Next, if you add an s to shipwreck, or shipwrecks, you will see it returns a list of documents. This is how you query either one or multiple documents in GraphQL.

Frontend

Before we visualize our shipwrecks collection, we need to learn a few things about Vue, Open Street Maps, and how to call our Realm backend.

For simplicity, we are going to define an anonymous authentication method, aka anyone can make a get call. We are going to use Vue Apollo. This is an easy way to integrate GraphQL + reactivity into your Vue app while mostly abstracting away the complexity.

We are also going to use a javascript library to visualize our data. I have found OpenLayers, and more specifically the Vue 3 Flavor, to be super simple to work with.

Now it's time to create the frontend to display our data. Even if you have never coded something in a javascript framework, you could still do this. If I am being honest, I think Vue2 is more beginner-friendly than Vue3. The thing is - Vue2 is a bunch of boilerplate. So much scaffolding but it's easy to organize your code.

Vue3, to me, feels like a mature beast. It is still approachable, but you are losing some of the bowling bumpers that Vue2 had. The tradeoff is there is way less code, and with <script setup> you can make a reactive front end in just a few lines. You are going to see see things like ref() and computed(() => {}). While you can read about these concepts in the docs, using them might be the quickest way to learn why and how these properties are used.

nicholasoxford / realmVueTemplate

Template for Going Serverless with MongoDB Realm & Vue 3

git clone https://github.com/nicholasoxford/realmVueTemplate.git
cd realmVueTemplate
npm i
npm run dev

View on GitHub

Let's start out by downloading my Github repo. It is a starting point that has Apollo, OpenLayers, and Vue3 preconfigured. I will also add a link at the end to a completed repo for you to test out. I highly recommend trying to follow the rest of the tutorial.

The first file we are going to look at is main.js. It is where we mount and configure packages like openLayersMap and Apollo. If you think about it, we want to be able to call our GraphQL data anywhere in the app. To do this we have to globally configure Realm on the client-side and tell Vue our URL.

const id = "test-iuege";
const config = {
  id,
};
const appRealm = new Realm.App(config);// Gets a valid Realm user access token to authenticate requests

// HTTP connection to the API
const httpLink = createHttpLink({
  // You should use an absolute URL here
  uri: 'https://realm.mongodb.com/api/client/v2.0/app/test-iuege/graphql',
  fetch: async (uri, options) => {
    const accessToken = await getValidAccessToken();
    options.headers.Authorization = `Bearer ${accessToken}`;
    return fetch(uri, options);
  },
})

async function getValidAccessToken() {
  // Guarantee that there's a logged in user with a valid access token
  console.log(appRealm)
  if (!appRealm.currentUser) {
    // If no user is logged in, log in an anonymous user. The logged in user will have a valid
    // access token.
    await appRealm.logIn(Realm.Credentials.anonymous());
  } else {
    // An already logged in user's access token might be stale. To guarantee that the token is
    // valid, we refresh the user's custom data which also refreshes their access token.
    await appRealm.currentUser.refreshCustomData();
  }
  return appRealm.currentUser.accessToken
}

Replace const id = "test-iuege"; with your RealmID:

Next click the GraphQL tab in the Mongo UI and copy and paste the URL on the right hand of the page. In the code replace the text of the variable URI with what is in your clipboard.

Finally, click the authentication tab, click the edit button next to Allow users to log in anonymously, and switch it to on. Remember you have to deploy your changes when using Realm. If you look at the main.js again, you see we call appRealm.login() with anonymous credentials. I am sure you could hand-code that, but these packages make it so easy to configure things like this on the client-side.

Before we change any frontend code, let us go ahead run npm run dev in the terminal. If you go to your link, most likely http://localhost:3000/, you will see the standard Vue getting started page. I think it is beneficial to have our app running so we can see the changes in real-time. This is known as Hot Module Reloading, or HMR. One last time, look back main.js and you will see import OpenLayersMap from 'vue3-openlayers'. This allows us to utilize OpenLayers components anywhere in our app.

Looking at Open Layer's Vue 3 Website, we see a list of components we can add to our template. With the fact I want to visualize more than one shipwreck, I chose the ol-geom-multi-point component. Looking at this page, we see the <template> code which highest level component is ol-map. I would recommend clicking the ol-map component page, and exploring the rest of the site. In my opinion, you can learn enough from just ol-geom-multi-point page, but it's helpful to see how other examples utilize the code.

On the site, below the template code, we see the examplescript code section. Because we are going to use the composition API, our final result might look a little different. Let's go ahead and jump back to VsCode (I don't want to hear it) and navigate to /components/HelloWorld.vue. Here you will need to delete or comment out everything in the <template> section.

Next, take everything from OpenLayers and replace what was just removed. Inside our updated <template> code, the component we will worry most about is:

<ol-geom-multi-point/>

In the code you copied over, you will see :coordinates= is equal to an array of long, lat coordinates, or an array of arrays! We are going to set coordinates to a variable later. If you scroll, you will see in the script section I have the code you need commented out. Go ahead and delete or comment the code that is already there. Notice how there is no return statement like there was in the online example. This is beauty of <script setup>... Thank you Evan You!

The other difference is that my center variable is different. This is because the online example shows some spots in the middle of china, about as far as you can get from shipwrecks. I put the center point to Port-au-Prince, which has a bunch of shipwrecks. Maybe in part 2 we could make it where, as we move the map, it queries our database for the closest shipwrecks. This is easy with MongoDB! It supports GeoJSON like PostgreSQL.

Even though I set the center to Haiti, there are no shipwrecks on your screen. We need to call our Realm instance! This couldn't be easier, as we did most of our configuration in main.js. We need to add two things to our import statement:

import gql from "graphql-tag";
import { useQuery, useResult } from "@vue/apollo-composable";

Looking back at the Vue3 Apollo Docs, we can learn all about queries. Hopefully, right now something is clicking, Realm has already automated a gnarly part of GraphQL: creating a query. For our example, we can leave out almost all of the fields, but just copy it from the GraphQL tab!

const { result} = useQuery(gql`
  query AllShips {
    shipwrecks {
      _id
      chart
      coordinates

    }
  }
`);

We could get everything out of that result object, but I recommend using const points = useResult(result). Instead of dealing with iteration, all the info you need is right there. Also, useResult can help with returning errors. Now we need to use a computed property. Computed properties watch for value changes and react to it, furthermore, it caches the result so it can help with performance. In the computed property we are going to map out the coordinates. If you think about it, we are creating an array of arrays.

const messages = computed(() => points.value ? points.value.map(x => x.coordinates) : [[]])

The last thing we need to do is set coordinates to equal our variable messages.

<ol-geom-multi-point :coordinates="messages"></ol-geom-multi-point>

If we click save and navigate back to our browser, we should see the shipwrecks! It is not pretty, but we have achieved two goals. First, we are calling our database and getting data back. After mapping it out, our front end is reacting and plotting it. All with a few lines of code!

In this tutorial we have gone from nothing, to having a website that is visualizing shipwreck data from a database we control. We are using the latest and greatest in Vue, utilizing <script setup>, the composition API, and GraphQL. We also set up authorization, cleaned our data, and validated schemas. In part 2 I can show deploying this app using Realm, and using Realm’s custom resolvers to query data based on Longitude and Latitude.

Just for posterity's sake, here is my <script> section.

<script setup>
import { useQuery, useResult } from "@vue/apollo-composable";
import { computed } from 'vue'
import gql from "graphql-tag";
const { result} = useQuery(gql`
  query AllShips {
    shipwrecks {
      _id
      chart
      coordinates

    }
  }
`);
const points = useResult(result)
const messages = computed(() => points.value ? points.value.map(x => x.coordinates) : [[]])
const center = [-72.333336, 18.533333];
const projection = "EPSG:4326";
const zoom = 9;
const rotation = 0;
const radius = 10;
const strokeWidth = 4;
const strokeColor = "red";
const fillColor = "white";
</script>

What we also can do is increase the "height" value in

<ol-map
    :loadTilesWhileAnimating="true"
    :loadTilesWhileInteracting="true"
    style="height: 1000px"
  >

To clean up, we can go back to App.vue and comment out the <img> element, click save and return to localhost:3000. Looking much better. Vue and Mongo are two products I love building with. It's a great mix of ease of getting off the ground and ability to craft a complex application or website. You can find a few examples of Apple.com using vue!

Let me know if there is anything you specifically want to see in part 2 😎!

Nicholas Oxford

An annotated guide to the 'Metaplex Candy Machine' Tutorial

Nick — Fri, 17 Sep 2021 23:46:31 +0000

exiled-apes / candy-machine-mint

Fork, config, customize and ship your own candy machine mint app on your own domain, ultra fast.

Candy-Machine-Mint

The Candy-Machine-Mint project is designed to let users fork, customize, and deploy their own candy machine mint app to a custom domain, ultra fast.

A candy machine is an on-chain Solana program (or smart contract) for managing fair mint. Fair mints:

Start and finish at the same time for everyone.
Won't accept your funds if they're out of NFTs to sell.

Getting Set Up

Prerequisites

Ensure you have recent versions of both node and yarn installed.
Follow the instructions here…

View on GitHub

NFTS! They are all the craze, and have been for a minute. There is at least something interesting about minting tokens, by the creator of the art, to signify someone "owns" something.

Earlier this year I got really into computer generated art. I automated some scripts that would take 8 hours on my personal computer down to 5 minutes on AWS.

I wanted to see if I could combine this computer generated art and timed releases for fun. More on that at a later date. Right now we are focusing on getting through this tutorial. Now I have never touched anything solana before today, and I am up and running. It's possible.

Tutorial Annotation as of September 17th, 2021

The only thing I would note about the top instructions is, I would also run

brew install jq

The yarn run package:macos build step did not work for me. I had to run:

npx pkg . -d --targets node14-macos-x64 --output bin/macos/metaplex

Next I used zsh and my path is /usr/local/bin so my command was

 cp bin/macos/metaplex /usr/local/bin

I followed the tutorial until:

I created a folder called assets in a random directory. I then added 5 images and 5 .json files. Here is my json file from 0.png

{
    "name": "png0",
    "symbol": "",
    "description": "testing dreamland",
    "seller_fee_basis_points": 5,
    "image": "https://www.arweave.net/abcd5678?ext=png",
    "external_url": "google.com",
    "collection": {
        "name": "Dreamland Test",
        "family": "Dreamland"
    },
    "properties": {
        "files": [
            {
                "uri": "https://www.arweave.net/abcd5678?ext=png",
                "type": "image/png"
            }
        ],
        "category": "image/png",
        "creators": [
            {
                "address": "REDACTED",
                "share": 100
            }
        ]
    }
}

Now it's my understanding that matrix replaces the url once you upload. The parts that matter are seller_fee_basis_points and creators. I'm not totally sure what is required, but this was a good read about the metadata file.

Next I verified all the properties they were looking for. This is where brew install jq is helpful. Lastly I just cd into assets directory so my final command was:

metaplex upload . --env devnet --keypair ~/.config/solana/devnet.json

The articles mentions multiple errors, I did not get any. Next we need to look at our cache file to grab the config id:

code .cache/devnet-temp

I would then give it a few minutes. The article says to call a metaplex verify but that cannot be done without a create candy machine. To create one in my terminal I run

metaplex create_candy_machine --keypair ~/.config/solana/devnet.json

And it returns: candy machine pubkey. Keep this value close.

Setting mint date

To set the mint date you need to pass in a date string. I learned this by running metaplex update_candy_machine -h

Now we have all the necessary values set, we need to head over to our .env file on our frontend.

// from .cache/devnet-temp
// config value
REACT_APP_CANDY_MACHINE_CONFIG=
// return value from create_candy_machine
// candy machine pubkey
REACT_APP_CANDY_MACHINE_ID=
// I just put my solana wallet address?
REACT_APP_TREASURY_ADDRESS=
// unix date
// 1631923920
REACT_APP_CANDY_START_DATE=1631923920

REACT_APP_SOLANA_NETWORK=devnet
REACT_APP_SOLANA_RPC_HOST=https://explorer-api.devnet.solana.com

I didn't include quotes with my values. After all of this you should be able to Yarn Start and be able to connect your wallet.

Shout out Levi Korg for putting so much work in. I'm excited to learn more about matrix and hopefully host my own auction.

Hope this helps someone!

Contributing to Fig.io (Autocomplete Tutorial Pt. 2)

Nick — Fri, 17 Sep 2021 22:50:09 +0000

Fig has improved my terminal experience in more ways than one. I was able to trim my oh-my-zsh profile to improve terminal start times. Through it VsCode style autocomplete, I'm now aware of flags and options on popular CLI command like git add, where the --all flag solved a pesky package.json change I was trying to stage.

Article No Longer Available

Fig's autocomplete is so good, that when a CLI doesn't have it - you notice. This was the case mongosh. Mongosh is a way to interact with your mongo clusters through the shell. It starts a node terminal, so you can rip javascript. I love it! However, I often need help crafting that connection query. Once I saw Fig didn't have mongosh autocomplete I honestly got a bit excited. Fig's autocomplete specs are open-sourced. Smart move by the founders, as it's worth it to me, to add certain specs I use a lot.

To be frank, when I was first downloading fig I saw the website sections on how you can contribute. My first thought was, this is probably more difficult than my learning tolerance will allow. I was completely wrong. Not only do they have a great guide on how to get your environment set up, but their overview of how command line arguments are made is even better.

The goal of an autocompletion spec is to outline the path a user can take with certain CLI packages. With npm you might start our with npm run or npm install. The available arguments between the two are wildly different. In the grand scheme of things, they are also both pretty simple commands. Luckily, Fig's spec is so flexible, you'll always find a solution to even seemingly abstract CLI.

After running:

npm run create-example

A file will be created inside the dev folder. Looking at that file we can start to see the template Fig follows. abc is or command - or in npm run install, npm is the command. Then we have our subcommand, checkout, which is the same as run. Then finally we have our options and/or arguments. Our main command has options like -v, as well does our subcommand. Once you get the mental model down of Fig, you can quickly code subcommand after subcommand. I'm also not a guy who can say I spend a lot of time in open source. I would like to, but I just don't feel like I have the technical ability. This is a great entry point into open source.

Let's talk about `mongosh` and Fig.

Most of the time you are passing a connection string into mongosh. You can think of that as a command -> argument input while most are command -> subcommand -> argument. This trips me up in the beginning. While the options of mongosh took the majority of the work, the top section is the most important. Here is what I wrote:

const completionSpec: Fig.Spec = {
  name: "mongosh",
  description:
    "The MongoDB Shell, mongosh  is a fully functional JavaScript and Node.js 14.x REPL environment for interacting with MongoDB deployments",
  args: {
    name: "Connection String",
    isOptional: true,
    default: "mongodb://localhost:27017",
    suggestions: [
      {
        name: "mongodb://localhost:27017",
        description:
          "Default Connection String; Equivalant to running mongosh without any commands",
      },
      {
        name: "mongodb+srv://cluster0.example.mongodb.net/sample_geospatial",
        description: "Atlas Connection String Example",
        priority: 35,
      },
    ],
  },

This shows us the capability of suggestions and defaults. When writing this code, I looked at other packages I understood. How did git implement something? The amount of extendibility you have with Fig is empowering. Not only am I just scratching the surface of Fig's capability, I'm sure the team is too.

feat: add autocomplete spec for `mongosh` #580

nicholasoxford posted on Sep 10, 2021

What kind of change does this PR introduce? (Bug fix, feature, docs update, ...)

Introduce CLI completion MongoDB's Command Line Tool.

I also noticed the PR to delete package-lock from the repo so I went ahead and did that too.

What is the current behavior? (You can also link to an open issue here)

No autocomplete

What is the new behavior (if this is a feature change)?

Additional info: https://docs.mongodb.com/mongodb-shell/reference/options/

View on GitHub

If you are wondering how I knew what to add for each field, I followed Mongo's mongosh reference spec 1 for 1. It really became almost a meditative task. Once I made the pull request, their devs made a handful of meaningful comments that improved the quality of code greatly. I think you can learn a lot by looking at my spec, the mongo reference, and it running in the terminal. Thing's like getting someone's filepath to autocomplete is as simple as:

generators: {
          template: "filepaths",
        },

Since pushing this PR, I've already added features to the Github CLI, and hope on adding some more in the future. Furthermore, if someone from MongoDB wants to collaborate, my twitter is @nick__atl. I feel like I might be missing something from mongosh.

Nicholas Oxford

An Introduction to mongocli, the easiest way to deploy an Atlas cluster!

Nick — Thu, 16 Sep 2021 22:26:38 +0000

Deploying infrastructure as code has seemed something worthy of the lucky few in the high castle. Yet, once you get pretty familiar with a product you want to stop going through a UI. With tools like Fig.io, using the command line is more accessible than ever. It's now possible that new developers aren't feeling like they are talking into a black-box.

Recently, I've been creating a lot of weekend projects. Standing up a cluster in Mongo, creating something kinda cool, hit some snag and then abandon the project. This type of coding is super productive. Anyways, because I've used Atlas so much I am constantly looking for ways to automate away the infrastructure. This is the idea behind terraform and chef. But this is the code for those mysterious SREs. I am sure I could figure it out, but I am a bit afraid I would end up deploying 7 sharded M400s clusters.

The Mongo Atlas CLI is a sweet spot between full infrastructure automation and using the UI. After running a simple authentication flow, the world is yours. You can mongocli atlas quickstart which will prompt an interactive cluster creation flow. It's probably helpful to do this at least once. Now, it's going to default you to an M10. This is probably as much as you need, but you are probably wondering how do I specify what tier I want!

Getting started

After running

brew install mongocli

We need to give our mongocli an authentication configuration. Lets create a pair of API keys to be able to fully configure Mongo Atlas services. To do this, navigate to Mongodb.com and log in. Select the dropdown: Access Manager --> Organization Access at the top of the page. We are giving mongocli more than just the rights to connect to an individual cluster. If you went ahead and tried the quickstart command, you would see at the end of the flow, it ran mongosh with your new connection string!

On the top right, we need to click Create API Key. You will see an input field for the name of our apiKey and what role we will give it. I named my mongoCli, and then chose Project Owner for Organization Permissions. While it's possible to give it lower permissions and still be beneficial. I want to transition to start using the UI as little as possible. The next screen will be your public and private api keys. Copy this to a note or VsCode.

By default, Mongo limits what IP address can access your clusters. This is done at a granular level, or different API keys can have different IP whitelist. Click Add Access List Entry and then "Us Current IP Address". Forgetting to whitelist my IP is something we will all get hit with at-least-once. Done.

mongocli config

Paste your public, then private key. And we are configured.

What are you, silly? Clearly you want to deploy to AWS, US-East-1. Real ones know if that one goes down - the world ain't working. You are also reasonably worried about the performance issues you will never have. Let us chose M30, 10 gigs. Even if I'm brave enough to adventure past the sample data and upload my own data. I'm sure my collection would never surpass 10k documents. Still, something just doesn't feel right about choosing M10. We're also going to use 5.0, so we need to pass that into our cluster create argument. You can learn more about Mongo Atlas CLI commands here.

mongocli atlas cluster create cliTest2 --provider AWS --region US_EAST_1 --members 3 --tier M30 --mdbVersion 5.0 --diskSizeGB 10

Replace <clusterName> with whatever your heart desires. But keep it close by, I chose cliTest2. If we head back to our Mongo UI, we should see that Mongo is deploying our cluster. This process takes about 7-10 minutes. Once it is done we can retrieve the connection string for our Atlas instance.

mongocli atlas clusters connectionStrings describe cliTest2

We can now use that connection string with mongosh and start querying our databases. We are just scratching the surface with mongocli - almost criminally so. The last thing we need to do to save our butts financially is terminate this cluster.

mongocli atlas clusters delete cliTest2

In a few minutes if we return back to our UI. We will see our cluster is now gone. Let me know if you are interested in learning more about the Mongo Atlas CLI.

Nicholas Oxford

Forem: Nick

The Hidden AI Cheating Crisis Costing Companies $125,000 Per Bad Hire

The Hidden AI Cheating Crisis Costing Companies $125,000 Per Bad Hire

How Cluely AI and Similar Tools Are Undermining Your Remote Interview Process

The $125,000 Problem No One's Talking About

How AI Interview Cheating Actually Works

Red Flags Every HR Professional Should Know

Technical Interview Red Flags:

Behavioral Interview Red Flags:

The Detection Challenge

Protecting Your Organization: A Strategic Approach

Immediate Actions:

Long-term Solutions:

The Legal and Ethical Implications

Industry Response and Future Outlook

Taking Action: Your Next Steps

Conclusion: The Time to Act is Now

Tags:

HumanResources #InterviewFraud #ArtificialIntelligence #RemoteWork #HiringBestPractices #TalentAcquisition #WorkplaceTechnology #InterviewSecurity #HRTechnology #RecruitmentFraud

[Boost]

Deploying Next.js + Pocketbase to a single Fly.io machine

Nick ・ Dec 15

Deploying Next.js + Pocketbase to a single Fly.io machine

nicholasoxford / pocketwatcher

🚀 Production-ready Next.js template with PocketBase and shadcn/ui. Includes authentication, beautiful UI components, and one-command deployment.

PocketWatcher

Overview

Features

Getting Started

Prerequisites

Local Development

Deploying Your Stack to fly.io

Install the Fly.io CLI if you haven't already

Getting Your Admin Access

Minting a tree for compressed NFTs

Getting started

Using Python to track NFT prices on FTX

Sign up for FTX Here

Deploying Your First Arweave Contract

Getting Started With Arweave

Getting started with Metaplex (A Solana NFT Journey PT. 1)

Don't use the metaplex binary to create a candy machine

That moment when everything clicks

exiled-apes / candy-machine-mint

Fork, config, customize and ship your own candy machine mint app on your own domain, ultra fast.

Candy-Machine-Mint

Getting Set Up

Prerequisites

Conclusion

Going Serverless with MongoDB Realm & Vue 3

Creating The Database 💾

Frontend

nicholasoxford / realmVueTemplate

Template for Going Serverless with MongoDB Realm & Vue 3

An annotated guide to the 'Metaplex Candy Machine' Tutorial

exiled-apes / candy-machine-mint

Fork, config, customize and ship your own candy machine mint app on your own domain, ultra fast.

Candy-Machine-Mint

Getting Set Up

Prerequisites

Tutorial Annotation as of September 17th, 2021

Setting mint date

Contributing to Fig.io (Autocomplete Tutorial Pt. 2)

Article No Longer Available

Let's talk about mongosh and Fig.

feat: add autocomplete spec for `mongosh` #580

An Introduction to mongocli, the easiest way to deploy an Atlas cluster!

Getting started

Let's talk about `mongosh` and Fig.