Quickstart

if (shipd.isEnabled("new-checkout")) {
  // new checkout
}

if client.IsEnabled("new-checkout", shipd.EvaluationContext{}) {
    // New checkout.
}

mkdir shipd-quickstart && cd shipd-quickstart
npm init -y && npm pkg set type=module
npm install shipdit
npm install -g @shipdit/cli
mkdir -p src .shipd

mkdir shipd-quickstart && cd shipd-quickstart
go mod init example.com/shipd-quickstart
go get github.com/alasti-company/useshipd.com/sdks/go
npm install -g @shipdit/cli

// shipd.config.ts
import { defineFlags } from "shipdit/config";

export default defineFlags({
  "new-checkout": {
    type: "boolean",
    default: false,
    description: "Redesigned checkout flow",
  },
});

// shipd.config.go
package main

import "github.com/alasti-company/useshipd.com/sdks/go/config"

var Config = config.ShipdConfig{
	"new-checkout": {
		Type:        "boolean",
		Default:     false,
		Description: "Redesigned checkout flow",
	},
}

shipd push

shipd push

// src/index.ts
import { createClient } from "shipdit";
import type { FlagDefinitions } from "./generated/flags";

const shipd = createClient<FlagDefinitions>({
  sdkKey: process.env.SHIPD_SDK_KEY!,
  stream: true,
  defaults: { "new-checkout": false },
});

await shipd.ready();

setInterval(() => {
  console.log("new-checkout:", shipd.isEnabled("new-checkout"));
}, 1000);

// main.go
package main

import (
	"context"
	"log"
	"os"
	"os/signal"
	"syscall"
	"time"

	"example.com/shipd-quickstart/internal/flags"
	shipd "github.com/alasti-company/useshipd.com/sdks/go"
)

func main() {
	client, err := shipd.New(shipd.Options{
		SDKKey: os.Getenv("SHIPD_SDK_KEY"), Defaults: flags.Defaults(),
	})
	if err != nil {
		log.Fatal(err)
	}
	defer func() {
		ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
		defer cancel()
		if err := client.Shutdown(ctx); err != nil {
			log.Printf("shipd events: %v", err)
		}
	}()
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	if err := client.Ready(ctx); err != nil {
		log.Printf("using defaults: %v", err)
	}
	cancel()
	shutdown, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
	defer stop()
	ticker := time.NewTicker(time.Second)
	defer ticker.Stop()
	for {
		select {
		case <-shutdown.Done():
			return
		case <-ticker.C:
			log.Printf("new-checkout: %v", flags.NewCheckout(client, shipd.EvaluationContext{}))
		}
	}
}

npx tsx src/index.ts

go run .