DEV Community: Eray Ates

Useful tools on 1.tools

Eray Ates — Fri, 09 Jan 2026 09:50:13 +0000

I've been working on 1.tools, an open-source collection of browser-based developer utilities.
I want to add static as possible and support big tools with wasm.

Working on backend side to add ability of the server side tools as well and not have to use them, all website still on static content served on github.

Tool Categories

Converters - JSON/YAML/TOML conversion, timestamps, cron parsing, number base conversion..
Encoders/Decoders - Base64, JWT, URL encoding, Morse code, Basic Auth..
Generators - UUIDs, passwords, QR codes, bcrypt hashes, fake data, RSA keys..
Graphics - Color picker, gradient generator, image compression, contrast checker..
Text - Diff viewer, regex tester, ASCII art, text transformations..
Network - CORS checker, subnet calculator, port reference..
Timers - World clock, countdown, stopwatch with lap timing..
Testers - Dead pixel test, input/gamepad tester, browser capabilities..
Party - Name picker wheel, dice roller, coin flipper, camera recorder..

Tech Stack
Astro 5 - Static site generation
Svelte 5 - UI components (using runes)
Tailwind 4 - Styling with CSS variables

Check it out: https://1.tools
Source: github.com/rytsh/bir

What tools do you use daily?
Would love feedback on what to add next.

Chore - control-flow requests

Eray Ates — Sat, 20 Aug 2022 12:22:11 +0000

I created this application so you can drag and drop design your API. It is a low-code app, and this kind of application in some areas is required. For example, you want to send a request to a bunch of APIs and wait for all of them to return ok and parse results to generate a new result and return that as an answer. So it isn't enjoyable when trying to write this process in coding. I have some of this kind of work to handle, so I want to create this app to do this kind of task in future very quickly.

https://github.com/worldline-go/chore

Let's use the CHORE

This tool required PostgreSQL to save all of the information there.
First run Postgres in somewhere, for quick I show in the container:

docker run -d --name postgres -p 5432:5432 -e POSTGRES_HOST_AUTH_METHOD=trust postgres:14.5-alpine

The chore tool required a schema that can create its tables and makes migrations, but we can use the default public schema for this demo.
Now open the chore tool, which you can download in the releases section in binary format. It is just one executable file and has no dependency.
https://github.com/worldline-go/chore/releases/
Or we can directly use the chore's container for this:

docker run -it --rm --name chore -p 8080:8080 -e STORE_HOST=172.17.0.1 -e STORE_SCHEMA=public ghcr.io/worldline-go/chore:latest

This tool also can get configuration from the vault, consul or file (TOML, YAML, JSON). So you can also use some of them or combine them.

Open http://localhost:8080/ and login with username as admin and password as admin. You can also set first initialize user settings in configuration.
In this application, we have three sections:

Control: we can create our control flow diagram here.
Auths: set HTTP headers here, including sensitive data like tokens. You will use this one in a request somewhere.
Templates: go-template area so you can create a template, feed with some object, and get the result.
For the demo to start, I can show you get some beers, parse them, combine names and return results.

Beer - control-flow

To get some beer information, I used this API: https://punkapi.com/documentation/v2.

First, go to the control section and create a control that gives a unique name.
Our flow always starts with the endpoint. You can multiple endpoints to do different jobs in the same control flow.
So our general flow show like that:

Endpoint: This is a flow entry, explain which HTTP method to communicate and whether it is public reachable or needs a TOKEN.
I set the endpoint name as 'names', this is not unique, and if you have more than one endpoint with the same name in this control flow, that will run also. Also, I set the method as 'GET' so I can directly call in the browser URL.

Requests: This is calling other HTTP services with some data. Our method is 'GET', so we do not need any data.
Here I write the URL as https://api.punkapi.com/v2/beers/1 and second request has https://api.punkapi.com/v2/beers/2.

Every node runs as a different goroutine, so we need to wait for them and get data. Here we need a script node.

We added a script node with two inputs, so this node waits for all data and initializes.

Script: This is Ecma 5.1 specifications script library called Goja; it must have the main named function and arguments as your inputs. The first input is your first argument.
Click the Open Editor button and write your script there:

function main(beer1, beer2) {
  return {
   names: [ beer1[0].name, beer2[0].name ]
  };
}

Don't forget to click save after that.

As you see, the script node has three outputs, which we saw in requests.

'F' means your code has thrown an error; flow goes to F.
'T' means everything works fine.
'R' is false or true. Run it.

And our flow's last step is to respond.

I am sending what I get in the script node as a body to respond. But I also need some headers to say this is a JSON value.

You also see 'Get respond in data' this button is usable just after the request node, so if you click this button and the previous node is a requesting node, you will get every detail to respond code and headers in there (our headers will append in that time).

Now, let's run it. You can use the Send section or directly send it to the browser.

Send section for testing, and it explains your curl command:

So our URL is
http://localhost:8080/api/v1/send?control=beer&endpoint=names

Call in browser:

Yeyyyy, you write your first API. Well done.

You can write much more complicated stuff in there. I have already added some helper nodes, and in the future, I will add more and make plugins for them.

Thanks for your use; if you have any questions, write in the comments!

Share docker socket to http rest with some filtering

Eray Ates — Sun, 24 Jul 2022 16:09:01 +0000

I will share socket files to http with forward tool, https://github.com/worldline-go/forward which I programmed.

This tool listening http request and forwarding to the socket with some method filtering.

So lets download or run in docker:

To download visit the release page

# scratch version
docker pull ghcr.io/worldline-go/forward:v0.1.2
# alpine version
docker pull ghcr.io/worldline-go/forward:v0.1.2-alpine

This tool asking you a command parameter to show location of the socket file and redirection path and some filtering methods.

In here, I will redirect all /docker/* requests to the docker.sock file. And I will disabled some method, so without any filtering methods all methods is works.

Using - begining on the method name is disabling:

-s /docker.sock:/docker/:-POST,-PUT,-DELETE,-PATCH

export socket to HTTP
version: 0.1.2 commit: b8e86c7 buildDate:2022-06-29T10:46:25Z

Usage:
  forward [flags]

Flags:
  -h, --help                 help for forward
  -H, --host string          Host to listen on, default: 0.0.0.0:8080 (default "0.0.0.0:8080")
  -s, --socket stringArray   Socket to export: /var/run/docker.sock:/docker/:*,-POST,-PUT,-DELETE
  -v, --version              version for forward

Lets run

docker run --rm -p 8080:8080 -v /var/run/docker.sock:/docker.sock ghcr.io/worldline-go/forward:v0.1.2 -s /docker.sock:/docker/:-POST,-PUT,-DELETE,-PATCH

Now call http service, (check this document for detail)

curl http://localhost:8080/docker/containers/json

I shared to the /docker path so I called with /docker prefix but this is for just demo not need to set any path.

Now, we can use this tool for in traefik.

Traefik is a proxy tool and in swarm mode it is need a docker.sock communication to find services's information.

We can mount docker.sock to Traefik and solve communication but there is one point. In the swarm's worker nodes docker.sock cannot reach to the swarm-api (default). We can fix this communication to run forward tool as service and set Traefik to the our service to communicate with docker socket.

Forward service

forward-docker:
  image: ghcr.io/worldline-go/forward:v0.1.2
  command: "-s /var/run/docker.sock::-POST,-PUT,-PATCH,-DELETE"
  deploy:
    mode: global
    # Just works in manager nodes for swarm API
    placement:
      constraints:
        - "node.role==manager"
  volumes:
    - /var/run/docker.sock:/var/run/docker.sock
  networks:
    - proxy

In traefik's static configuration change enpoint

providers:
  docker:
    # endpoint: "unix///var/run/docker.sock"
    endpoint: "tcp://forward-docker:8080"

Now you can replicate your Traefik in the all nodes of the swarm.

Read long-short syntax of config in Go

Eray Ates — Sun, 24 Jul 2022 15:04:26 +0000

Lets think we have config file like: (I use json)

This is short syntax

{
    "network": "test-network"
}

And long syntax

{
    "network": {
        "name": "test-network",
        "description": "for testing purposes"
    }
}

When reading this configurations we should give own decoder function to parse and write to the our object.

Before to do that lets check our example.

First create struct for long and short format and try unmarshal.

package main

import (
    "encoding/json"
    "fmt"
)

type NetworkDescription struct {
    Name        string `json:"name"`
    Description string `json:"description"`
}

type NetworkLong struct {
    Network NetworkDescription `json:"network"`
}

type NetworkShort struct {
    Network string `json:"network"`
}

func main() {
    networkLongTest1 := &NetworkLong{}
    err := json.Unmarshal([]byte(`{"network":{"name":"foo","description":"bar"}}`), networkLongTest1)
    fmt.Printf("%#v\nErr: %v", networkLongTest1, err)

    networkLongTest2 := &NetworkLong{}
    err = json.Unmarshal([]byte(`{"network":"foo"}`), networkLongTest2)
    fmt.Printf("%#v\nErr: %v", networkLongTest2, err)
}

Result obviously give error in second try

$ go run main.go
&main.NetworkLong{Network:main.NetworkDescription{Name:"foo", Description:"bar"}}
Err: <nil>
&main.NetworkLong{Network:main.NetworkDescription{Name:"", Description:""}}
Err: json: cannot unmarshal string into Go struct field NetworkLong.network of type main.NetworkDescription

Good now we can use this error in our custom Unmarshaler's interface implementation.

I am using stdlib's json to unmarshaller so Unmarshaler interface has one function UnmarshalJSON([]byte) error

We can create new struct type and use that one but I will just modify our NetworkLong struct because I will turn short version to the long.

type NetworkLong struct {
    Network NetworkDescription `json:"network"`
}

func (n *NetworkLong) UnmarshalJSON(b []byte) error {
    // change type to don't use our custom unmarshal
    type longFormat NetworkLong
    nLong := &longFormat{}
    err := json.Unmarshal(b, &nLong)
    if err != nil {
        nShort := &NetworkShort{}
        err = json.Unmarshal(b, nShort)
        if err != nil {
            return err
        }

        n.Network = NetworkDescription{
            Name: nShort.Network,
        }

        return nil
    }

    *n = NetworkLong(*nLong)

    return nil
}

And our result is

&main.NetworkLong{Network:main.NetworkDescription{Name:"foo", Description:"bar"}}
Err: <nil>
&main.NetworkLong{Network:main.NetworkDescription{Name:"foo", Description:""}}
Err: <nil>

Check in the playground

Go Template Playground

Eray Ates — Wed, 22 Dec 2021 08:02:15 +0000

If you need to test go template with sprig functionality and HTML, Text template switch settings. https://repeatit.io meet these needs.
I made it with very little code and it is working on browser with go's webassembly output.

First start, use promise in go code. So we can return error and see it in browser. When creating promise in javascript, you are adding a function which is take resolve and reject parameters.
In golang is same so our promise implementation like this.
Directly use main function arguments in promise function!

func Render(this js.Value, args []js.Value) interface{} {
    mainArgs := args

    handler := js.FuncOf(func(this js.Value, args []js.Value) interface{} {
        resolve := args[0]
        reject := args[1]

        go func() {
            data, err := renderWithError(mainArgs)
            if err != nil {
                errorConstructor := js.Global().Get("Error")
                errorObject := errorConstructor.New(err.Error())
                reject.Invoke(errorObject)
            } else {
                resolve.Invoke(js.ValueOf(data))
            }
        }()

        return nil
    })

    promiseConstructor := js.Global().Get("Promise")

    return promiseConstructor.New(handler)
}

After that set this function and use it with js.

renderjs := js.FuncOf(Render)
js.Global().Set("render", renderjs)

try {
  output = await render(values.input, values.template, config.template);
} catch (error) {
  // inform to somewhere
}

Whole website is opensource on https://github.com/rytsh/repeatit

If you want to see a feature about that write me I will handle it.

          _---~~\\~~----_
  _ / _ *^____      _____``*h*\"*/
 / __/ /'     ^   /      \ ^@q   F
[  @L | @))    |  | @))   l  0 _/
 \ /   \~____ / __ \_____/    \
  |           _l__l_           I
  }          [______]           I
  ]            | | |            |
  ]             ~ ~             |

https://javascript.info/promise-basics
https://gist.github.com/belbomemo/b5e7dad10fa567a5fe8a

Embed map in JSON output

Eray Ates — Tue, 19 Oct 2021 11:51:56 +0000

The easy way to embed a map to struct's JSON output is to implement a custom MarshalJSON function.

First, let's define a small struct:

type test struct {
    KeyValue map[string]interface{}
    Info     string
}

Concrete struct and run json.Marshal to see the result.

myStruct := test{
    Info: "Testing Struct",
}

myStruct.KeyValue = make(map[string]interface{})

myStruct.KeyValue["language"] = "go"
myStruct.KeyValue["year"] = 2007

// print result
rest, err := json.Marshal(myStruct)
if err != nil {
    println(err)

    return
}

println(string(rest))

So the result is clearly:

{"KeyValue":{"language":"go","year":2007},"Info":"Testing Struct"}

Now adding a MarshalJSON method to our struct and embed the KeyValue part in the output.

func (m test) MarshalJSON() ([]byte, error) {

This first interface is used without a pointer of the test, so this is more useful. If you use a pointer method, you should give the address of your concrete struct to json.Marshal.

Then continue to implement, make same as before output.

func (m test) MarshalJSON() ([]byte, error) {
    type newTestType test

    // marshal everything with json's original method
    preByte, err := json.Marshal(&struct {
        *newTestType
    }{
        newTestType: (*newTestType)(&m),
    })

    return preByte, err
}

Here, we cannot use json.Marshal(m) in our MarshalJSON method. Because it always triggers our method, it will make a fatal error: stack overflow. So we are adding a new type based on our type and now the new type doesn't have MarshalJSON method, and we can use it in json.Marshal.

Now we got the same output as before:

{"KeyValue":{"language":"go","year":2007},"Info":"Testing Struct"}

So after that, we can add everything directly to preByte value to affect the result. But first, we need to disable KeyValue field in our output because we will add it manually.

Add JSON tags to struct:

type test struct {
    KeyValue map[string]interface{} `json:"-"`
    Info     string                 `json:"info"`
}

Now we cannot see the KeyValue in the output of json.Marshal.

Append our bytes and new custom MarshalJSON method:

func (m test) MarshalJSON() ([]byte, error) {
    // using to disable recursive this function
    type newTestType test

    // marshal everything with json's original method
    preByte, err := json.Marshal(&struct {
        *newTestType
    }{
        newTestType: (*newTestType)(&m),
    })

    if err != nil {
        return nil, err
    }

    buffer := bytes.NewBuffer([]byte{})

    // delete close bracket
    buffer.Write(preByte[:len(preByte)-1])

    // add new values to buffer
    length := len(m.KeyValue)
    count := 0

    if length > 0 {
        buffer.WriteString(",")
    }

    for key, value := range m.KeyValue {
        jsonValue, err := json.Marshal(value)
        if err != nil {
            return nil, err
        }

        buffer.WriteString(fmt.Sprintf("\"%s\":%s", key, string(jsonValue)))
        count++

        if count < length {
            buffer.WriteString(",")
        }
    }

    buffer.WriteString("}")

    return buffer.Bytes(), nil
}

In here, get an empty buffer and fill our original json.Marshal output and delete the last character, which is } in our case after that added manually to our byte buffer. Used json.Marshal again for values of map.

Result

{"info":"Testing Struct","language":"go","year":2007}

But there is a one missing part we don't check duplicate keys. If your map has "info" key you will see twice!

To check all code

https://play.golang.org/p/hDIqyijyYhS

https://gist.github.com/rytsh/05f14c9e7ec364a5a108806339b85b09

Change filenames

Eray Ates — Fri, 11 Jun 2021 04:06:08 +0000

If you want to change filenames with given a prefix and do it in all inner folders, its little bit problem so this problem can solve easily with find sed and awk programs but I want to show a way just some script.

Lets define a deep first search algorithm for folders and get filenames.

After that goes to deep folder, first searching files with regular expressions (Added asterix to code due to passing asterix cause passing all filenames to function) and executing that filename with our ${2} given function.

[[ -n ${2} ]] && (${2} ${file})

Good, now can prepare change filename function and give it to this script. As you see ${file} will be our first argument ${1}.

function changeFileName() { mv $(pwd)/${1} $(pwd)/_${1}; }
export -f changeFileName

Ok than,

./check.sh .scss changeFileName

Now I added prefix underscore for all my related files in all folders.

Make Icon Component

Eray Ates — Fri, 07 May 2021 17:09:07 +0000

When using an icon in a web framework, a predefined component is used like fontawesome. But if you have just a few icons or want to use a custom icon, I will show you how to make your own component with SVG.

For SVG, I get from https://iconmonstr.com/ which is a very cool icons have.

<script lang="ts">
/* eslint-disable no-unused-vars */

enum IconTypes {
  plus = "M24 9h-9v-9h-6v9h-9v6h9v9h6v-9h9z",
  arrow = "M8.122 24l-4.122-4 8-8-8-8 4.122-4 11.878 12z",
}
type IconTypesString = keyof typeof IconTypes;

type PosTypes = "left" | "down" | "up" | undefined;

export let icon: IconTypesString;

export let height = "24";
export let width = "24";

export let className: string = undefined;
export let position: PosTypes = undefined;

const totalClass = [className, position].join(" ");
</script>

<svg xmlns="http://www.w3.org/2000/svg"
  class={totalClass ? totalClass : undefined}
  width="{width}"
  height="{height}"
  viewBox="0 0 24 24">
  <path d={IconTypes[icon]}/>
</svg>

<style lang="scss">
  .left {
    transform: rotate(180deg);
  }

  .down {
    transform: rotate(90deg);
  }

  .up {
    transform: rotate(-90deg);
  }
</style>

Added an enumerate to list of icons as type so when we using this component, it will help autocomplete.
Transformation CSS variable using for not repeating icons also added custom className props to control your icon in CSS part.
I fixed viewBox to 0 0 24 24 so width and height can works. But if your SVG is different than 24-24 you should update viewBox after that you can change value with width and height.

That's all welcome your new icon component.

<Icon icon="arrow" className="arrow" position="left"/>

If you need to middle of the content just wrap with flex use align-items center.