David Pennington xeoncross

I'm looking at OpenAPI generation and I see three main forms:

Service + Design

I really like the look of go-restful when it comes to adding hundreds of api endpoints. You define your service (actual business logic) and you define your routes with request/response structs and you're done. Validation, decoding/encoding, swagger docs, etc... is all taken care of - but you can only use HTTP. https://github.com/emicklei/go-restful-openapi/blob/dec9f41f12/examples/user-resource.go

Service + Design + Boilerplate

Next you have go-kit which requires additional definitions for decoding, but also allows you to define different transports (HTTP, gRPC, cli, and even NATS!) still, for rest-only servers seems like overkill to have to write all that boilerplate code for each service method. https://github.com/go-kit/examples/blob/master/stringsvc4/main.go#L153-L205

Demo: https://play.golang.org/p/qk20EKdlRuL

One message (somewhere in the chain of errors) is for the user - the rest are for the logs. The idea is that you can still put plenty of debugging information in the full error logs ("SQL error") - but show a nice, safe message to the client ("user not found").

Based on the following articles (discussed above)

https://middlemost.com/failure-is-your-domain/ https://commandcenter.blogspot.com/2017/12/error-handling-in-upspin.html https://blog.questionable.services/article/http-handler-error-handling-revisited/ https://go.dev/blog/error-handling-and-go

A demo "counter" + async application (codesandbox) is provided for each of the following four state libraries. The Zustand codesandbox includes three versions: vanila, immer, and redux-like

Redux Toolkit

OpenAPI

RTK Query has a (currently experimental) code-gen tool that will take an OpenAPI spec or GraphQL schema and give you a typed API client, as well as provide methods for enhancing the generated client after the fact.

https://redux-toolkit.js.org/rtk-query/comparison

Just saw that cloudflare created https://developers.cloudflare.com/workers/learning/using-durable-objects

Background: Regular lambda/worker/serverless functions are state-less - they have no persistent memory and are created and destroyed often; the are ephemeral.

For those of us that use these, we often default to having a stateful server somewhere (pubsub, websockets, chatroom organizer, rate-limiter, etc..). Often the database or filesystem (lock files) can be used as the manager of state or "source of truth".

Cloudflare basically created long-lived, single-instance lambda functions here. Now they can keep an hash of websocket connections or recent chat messages allowing multiple other short-lived (regular) serverless functions to use them like a regular webserver.

It's the new, old server pretending to be serverless. An expected, but still interesting development.

Cloudflare workers + auto deployments of staging branches

Using github actions to create the wrangler.toml domain name would let us use the default commit sha or branch name as the subdomain.

Inside the workers-deploy.yml you could build the domain name using the github action vars:

echo "[env.production]\nname=\"${GITHUB_REF}.example.com\"" > ~/.wrangler/config/domain.toml

	// cc-scanner impfmt.Errorf("HTTP error for %s: %v", url, err)orts domains from the Common Crawl URL index
	//
	// LICENCE: No licence is provided for this project

	package main

	import (
	"bufio"
	"context"
	"encoding/json"

	/*
	I'm playing with compression using dictionaries (for learning) and needed to figure out the logic for when saving 6 bits across two different byte boundaries. Basically, when storing multiple 6 bit values in regular 8 bit bytes, how do you calculate the bit shifting needed to split the bits up between different bytes in the []byte slice?

	https://goplay.space/#dfgOt3sGJzN
	*/
	func TestManualBytes(t *testing.T) {

	//
	// Demo 1: manual
	//

	MYSQL_HOST=127.0.0.1
	MYSQL_USER=hello
	MYSQL_PASS=world
	MYSQL_NAME=myapp
	MYSQL_PORT=3306

	package main

	import (
	"database/sql"
	"database/sql/driver"
	"fmt"
	"strings"
	)

	type Mapper interface {

	{
	"editor.formatOnSave": true,
	"editor.defaultFormatter": "golang.go",
	"workbench.colorTheme": "Alabaster",
	"settingsSync.ignoredExtensions": [

	],
	"workbench.colorCustomizations": {
	// "editor.background": "#F1F1F1",
	},