Forem: moznion

openapi-fetch-gen – Generate TypeScript API client from OpenAPI TypeScript interface definitions created by openapi-typescript

moznion — Sun, 20 Apr 2025 06:56:44 +0000

moznion / openapi-fetch-gen

Generate TypeScript API client from OpenAPI TypeScript interface definitions created by openapi-typescript (https://github.com/openapi-ts/openapi-typescript).

openapi-fetch-gen

Generate TypeScript API client from OpenAPI TypeScript interface definitions created by openapi-typescript.

This tool takes TypeScript interface definitions generated by openapi-typescript and creates a fully typed API client using openapi-fetch.

How It Works

Parse the TypeScript schema file generated by openapi-typescript
Extract all API endpoints, their HTTP methods, and parameter structures from the schema
Generate typed wrapper functions for each endpoint
Export a fully-typed client that provides
- A base client instance created with createClient from openapi-fetch
- Individual typed functions for each API endpoint
- Type helpers for parameters and responses

Installation

npm install --save-dev @moznion/openapi-fetch-gen

Usage

CLI

npx openapi-fetch-gen --input ./schema.d.ts --output ./client.ts

Options:

  -V, --version                     output the version number
  -i, --input <path>                path to input OpenAPI TypeScript definition file
  -o, --output <path>               path to output generated client file (default: "./client.ts")
  --use-operation-id                use operationId from OpenAPI schema for method names instead of generating from path (default: false)
  --parse-as-mapping

…

View on GitHub

This tool has already been published to the npm registry. You can install it by running:

npm install @moznion/openapi-fetch-gen

Background/Motivation

The goal of openapi-fetch-gen is to automatically generate a fully-typed TypeScript API client from the .d.ts schema generated by openapi-ts/openapi-typescript.

openapi-ts/openapi-typescript is a powerful tool for generating TypeScript schema definitions from OpenAPI 3 specifications. The same organization also provides openapi-fetch, a type-safe fetch client library designed to work seamlessly with these generated schemas. Although very useful, one notable hurdle with openapi-fetch is that developers must manually implement client code for each API endpoint.

How This Tool Works

For instance, suppose you have an OpenAPI 3 YAML definition like the following:

schema.yaml (a bit long, but imagine a typical REST API definition)

openapi: 3.0.3
info:
  title: Fictional Library User Management Service API
  version: 1.0.0
  description: |
    A RESTful API for managing library user records and their loan information.
servers:
  - url: https://api.fictionallibrary.example.com/v1
    description: Production server

paths:
  /users/{userId}:
    parameters:
      - $ref: '#/components/parameters/userId'
      - name: Authorization
        in: header
        required: true
        schema:
          type: string
        description: Authorization Header
      - name: Application-Version
        in: header
        required: true
        schema:
          type: string
        description: Application version
      - name: Something-Id
        in: header
        required: true
        schema:
          type: string
        description: Identifier of something
    get:
      summary: Get user details
      description: Retrieve detailed information for a specific user.
      responses:
        '200':
          description: User details
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/User'
        '400':
          $ref: '#/components/responses/BadRequest'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '403':
          $ref: '#/components/responses/Forbidden'
        '404':
          $ref: '#/components/responses/NotFound'

    put:
      summary: Replace user
      description: Replace a user's entire record.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/UserUpdate'
      responses:
        '200':
          description: Updated user record
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/User'
        '400':
          $ref: '#/components/responses/BadRequest'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '403':
          $ref: '#/components/responses/Forbidden'
        '404':
          $ref: '#/components/responses/NotFound'

    patch:
      summary: Update user fields
      description: Partially update a user's information.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/UserPatch'
      responses:
        '200':
          description: Updated user record
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/User'
        '400':
          $ref: '#/components/responses/BadRequest'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '403':
          $ref: '#/components/responses/Forbidden'
        '404':
          $ref: '#/components/responses/NotFound'

    delete:
      summary: Delete user
      description: Soft-delete a user record.
      responses:
        '204':
          description: User deleted (no content)
        '400':
          $ref: '#/components/responses/BadRequest'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '403':
          $ref: '#/components/responses/Forbidden'
        '404':
          $ref: '#/components/responses/NotFound'

components:
  parameters:
    userId:
      name: userId
      in: path
      required: true
      description: Unique user identifier (UUID)
      schema:
        type: string
        format: uuid

  responses:
    BadRequest:
      description: Bad request due to invalid input
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
    Unauthorized:
      description: Authentication required or failed
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
    Forbidden:
      description: Insufficient permissions to access resource
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
    NotFound:
      description: Resource not found
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
    Conflict:
      description: Conflict with current state of the resource
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'

  schemas:
    Error:
      type: object
      properties:
        code:
          type: integer
          description: HTTP status code
        message:
          type: string
          description: Error message detailing the cause
      required:
        - code
        - message

    User:
      type: object
      properties:
        id:
          type: string
          format: uuid
        name:
          type: string
        email:
          type: string
          format: email
        membershipType:
          type: string
          enum: [REGULAR, PREMIUM, STUDENT]
        registeredAt:
          type: string
          format: date-time
        address:
          $ref: '#/components/schemas/Address'
      required:
        - id
        - name
        - email
        - membershipType
        - registeredAt

    Address:
      type: object
      properties:
        postalCode:
          type: string
        street:
          type: string
        city:
          type: string
        country:
          type: string
      required:
        - street
        - city
        - country

    UserCreate:
      type: object
      properties:
        name:
          type: string
        email:
          type: string
          format: email
        membershipType:
          type: string
          enum: [REGULAR, PREMIUM, STUDENT]
        address:
          $ref: '#/components/schemas/Address'
      required:
        - name
        - email
        - membershipType

    UserUpdate:
      allOf:
        - $ref: '#/components/schemas/UserCreate'
        - type: object
          properties:
            id:
              type: string
              format: uuid
          required:
            - id

    UserPatch:
      type: object
      description: Schema for partial updates – include only fields to change
      properties:
        name:
          type: string
        email:
          type: string
          format: email
        membershipType:
          type: string
          enum: [REGULAR, PREMIUM, STUDENT]
        address:
          $ref: '#/components/schemas/Address'

Next, you execute:

openapi-typescript --output schema.d.ts ./schema.yaml

This generates a TypeScript interface definition file named schema.d.ts:

schema.d.ts

/**
 * This file was auto-generated by openapi-typescript.
 * Do not make direct changes to the file.
 */

export interface paths {
    "/users/{userId}": {
        parameters: {
            query?: never;
            header: {
                /** @description Authorization Header */
                Authorization: string;
                /** @description Application version */
                "Application-Version": string;
                /** @description Identifier of something */
                "Something-Id": string;
            };
            path: {
                /** @description Unique user identifier (UUID) */
                userId: components["parameters"]["userId"];
            };
            cookie?: never;
        };
        /**
         * Get user details
         * @description Retrieve detailed information for a specific user.
         */
        get: {
            parameters: {
                query?: never;
                header: {
                    /** @description Authorization Header */
                    Authorization: string;
                    /** @description Application version */
                    "Application-Version": string;
                    /** @description Identifier of something */
                    "Something-Id": string;
                };
                path: {
                    /** @description Unique user identifier (UUID) */
                    userId: components["parameters"]["userId"];
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description User details */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["User"];
                    };
                };
                400: components["responses"]["BadRequest"];
                401: components["responses"]["Unauthorized"];
                403: components["responses"]["Forbidden"];
                404: components["responses"]["NotFound"];
            };
        };
        /**
         * Replace user
         * @description Replace a user's entire record.
         */
        put: {
            parameters: {
                query?: never;
                header: {
                    /** @description Authorization Header */
                    Authorization: string;
                    /** @description Application version */
                    "Application-Version": string;
                    /** @description Identifier of something */
                    "Something-Id": string;
                };
                path: {
                    /** @description Unique user identifier (UUID) */
                    userId: components["parameters"]["userId"];
                };
                cookie?: never;
            };
            requestBody: {
                content: {
                    "application/json": components["schemas"]["UserUpdate"];
                };
            };
            responses: {
                /** @description Updated user record */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["User"];
                    };
                };
                400: components["responses"]["BadRequest"];
                401: components["responses"]["Unauthorized"];
                403: components["responses"]["Forbidden"];
                404: components["responses"]["NotFound"];
            };
        };
        post?: never;
        /**
         * Delete user
         * @description Soft-delete a user record.
         */
        delete: {
            parameters: {
                query?: never;
                header: {
                    /** @description Authorization Header */
                    Authorization: string;
                    /** @description Application version */
                    "Application-Version": string;
                    /** @description Identifier of something */
                    "Something-Id": string;
                };
                path: {
                    /** @description Unique user identifier (UUID) */
                    userId: components["parameters"]["userId"];
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description User deleted (no content) */
                204: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
                400: components["responses"]["BadRequest"];
                401: components["responses"]["Unauthorized"];
                403: components["responses"]["Forbidden"];
                404: components["responses"]["NotFound"];
            };
        };
        options?: never;
        head?: never;
        /**
         * Update user fields
         * @description Partially update a user's information.
         */
        patch: {
            parameters: {
                query?: never;
                header: {
                    /** @description Authorization Header */
                    Authorization: string;
                    /** @description Application version */
                    "Application-Version": string;
                    /** @description Identifier of something */
                    "Something-Id": string;
                };
                path: {
                    /** @description Unique user identifier (UUID) */
                    userId: components["parameters"]["userId"];
                };
                cookie?: never;
            };
            requestBody: {
                content: {
                    "application/json": components["schemas"]["UserPatch"];
                };
            };
            responses: {
                /** @description Updated user record */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["User"];
                    };
                };
                400: components["responses"]["BadRequest"];
                401: components["responses"]["Unauthorized"];
                403: components["responses"]["Forbidden"];
                404: components["responses"]["NotFound"];
            };
        };
        trace?: never;
    };
}
export type webhooks = Record<string, never>;
export interface components {
    schemas: {
        Error: {
            /** @description HTTP status code */
            code: number;
            /** @description Error message detailing the cause */
            message: string;
        };
        User: {
            /** Format: uuid */
            id: string;
            name: string;
            /** Format: email */
            email: string;
            /** @enum {string} */
            membershipType: "REGULAR" | "PREMIUM" | "STUDENT";
            /** Format: date-time */
            registeredAt: string;
            address?: components["schemas"]["Address"];
        };
        Address: {
            postalCode?: string;
            street: string;
            city: string;
            country: string;
        };
        UserCreate: {
            name: string;
            /** Format: email */
            email: string;
            /** @enum {string} */
            membershipType: "REGULAR" | "PREMIUM" | "STUDENT";
            address?: components["schemas"]["Address"];
        };
        UserUpdate: components["schemas"]["UserCreate"] & {
            /** Format: uuid */
            id: string;
        };
        /** @description Schema for partial updates – include only fields to change */
        UserPatch: {
            name?: string;
            /** Format: email */
            email?: string;
            /** @enum {string} */
            membershipType?: "REGULAR" | "PREMIUM" | "STUDENT";
            address?: components["schemas"]["Address"];
        };
    };
    responses: {
        /** @description Bad request due to invalid input */
        BadRequest: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["Error"];
            };
        };
        /** @description Authentication required or failed */
        Unauthorized: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["Error"];
            };
        };
        /** @description Insufficient permissions to access resource */
        Forbidden: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["Error"];
            };
        };
        /** @description Resource not found */
        NotFound: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["Error"];
            };
        };
        /** @description Conflict with current state of the resource */
        Conflict: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["Error"];
            };
        };
    };
    parameters: {
        /** @description Unique user identifier (UUID) */
        userId: string;
    };
    requestBodies: never;
    headers: never;
    pathItems: never;
}
export type $defs = Record<string, never>;
export type operations = Record<string, never>;

Previously, you would have needed to manually implement the API client for each endpoint using openapi-fetch. Now, with openapi-fetch-gen, the process is significantly simplified:

Just execute:

openapi-fetch-gen --input ./schema.d.ts --output ./generated_client.ts

This automatically generates the following fully-typed API client code:

import createClient, { type ClientOptions } from "openapi-fetch";
import type { paths } from "./schema"; // generated by openapi-typescript

export class Client {
  private readonly client;

  constructor(clientOptions: ClientOptions) {
    this.client = createClient<paths>(clientOptions);
  }

  ...

  /**
   * Replace user
   */
  async putUsersUserid(
    params: {
      header: {
        Authorization: string;
        "Application-Version": string;
        "Something-Id": string;
      };
      path: { userId: string };
    },
    body: {
      name: string;
      email: string;
      membershipType: "REGULAR" | "PREMIUM" | "STUDENT";
      address?: {
        postalCode?: string;
        street: string;
        city: string;
        country: string;
      };
    } & { id: string },
  ) {
    return await this.client.PUT("/users/{userId}", {
      params,
      body,
    });
  }
  ...
}

FYI: complete example of generated_client.ts

// THIS FILE IS AUTO-GENERATED BY openapi-fetch-gen.
// DO NOT EDIT THIS FILE MANUALLY.
// See Also: https://github.com/moznion/openapi-fetch-gen
import createClient, { type ClientOptions } from "openapi-fetch";
import type { paths } from "./schema"; // generated by openapi-typescript

export class Client {
  private readonly client;

  constructor(clientOptions: ClientOptions) {
    this.client = createClient<paths>(clientOptions);
  }

  /**
   * Get user details
   */
  async getUsersUserid(params: {
    header: {
      Authorization: string;
      "Application-Version": string;
      "Something-Id": string;
    };
    path: { userId: string };
  }) {
    return await this.client.GET("/users/{userId}", {
      params,
    });
  }

  /**
   * Replace user
   */
  async putUsersUserid(
    params: {
      header: {
        Authorization: string;
        "Application-Version": string;
        "Something-Id": string;
      };
      path: { userId: string };
    },
    body: {
      name: string;
      email: string;
      membershipType: "REGULAR" | "PREMIUM" | "STUDENT";
      address?: {
        postalCode?: string;
        street: string;
        city: string;
        country: string;
      };
    } & { id: string },
  ) {
    return await this.client.PUT("/users/{userId}", {
      params,
      body,
    });
  }

  /**
   * Delete user
   */
  async deleteUsersUserid(params: {
    header: {
      Authorization: string;
      "Application-Version": string;
      "Something-Id": string;
    };
    path: { userId: string };
  }) {
    return await this.client.DELETE("/users/{userId}", {
      params,
    });
  }

  /**
   * Update user fields
   */
  async patchUsersUserid(
    params: {
      header: {
        Authorization: string;
        "Application-Version": string;
        "Something-Id": string;
      };
      path: { userId: string };
    },
    body: {
      name?: string;
      email?: string;
      membershipType?: "REGULAR" | "PREMIUM" | "STUDENT";
      address?: {
        postalCode?: string;
        street: string;
        city: string;
        country: string;
      };
    },
  ) {
    return await this.client.PATCH("/users/{userId}", {
      params,
      body,
    });
  }
}

That's all there is to it! ✨

Under the Hood

This tool analyzes the provided .d.ts file using the TypeScript Compiler API via the dsherret/ts-morph library and generates the corresponding TypeScript API client code based on the analyzed structure.

Wrap-up

In summary, openapi-fetch-gen automates the generation of a TypeScript API client layer directly from the openapi-typescript schema definitions, removing the need for tedious manual implementation.

Additionally, this tool supports a "Default HTTP Headers" feature that simplifies type definitions for client users. The original implementation required explicitly passing headers (e.g., Authorization) in many methods. To simplify this, openapi-fetch-gen uses a clever type-level trick to handle these headers more gracefully. If you're interested, please refer to the Default HTTP Headers section.

go-iprtb: Pure Go IP Routing Table Implementation

moznion — Mon, 14 Nov 2022 08:25:39 +0000

I published a golang library that provides IP routing table implementation.

https://github.com/moznion/go-iprtb

When I googled by a query like "Golang routing table", then there were libraries that provide the function to manipulate OS-level routing table but I couldn't find out a library to implement/process the IP routing table on the user-level. That user-level one was my needed thing so I wrote this library.

In fact, it is easy to write a simple IP routing table in Golang. Just writing like the following code would satisfy the features of the routing table.

type RouteEntry struct {
    Destination net.IPNet
    Gateway     net.IP
    NwInterface string
    Metric      int
}

routes := map[string]RouteEntry{}
// Register routes here

// Following loops check whether the `target net.IP` matches with the routing table
var matched RouteEntry
var everMatched bool
for _, r := range routes {
    if r.Destination.Contains(target) {
        if !everMatched {
            matched = r
            everMatched = true
            continue
        }

        matchedMaskLen, _ := matched.Destination.Mask.Size()
        newRouteMaskLen, _ := r.Destination.Mask.Size()
        if newRouteMaskLen > matchedMaskLen { // for longest match
            matched = r
        }
    }
}

fmt.Println(matched)

Bur this code has a problem: when it respects the longest match, it has to scan all registered routes as linear, so the computation cost increases according to the number of entries in a table.
So once these routes have been able to transform into a prefix tree data structure, it can determine whether the target address matches the routing table by only traversing paths of that tree only one time (i.e. without backtracking).

For example, when there are three subnets 10.0.0.0/8, 192.0.0.0/8, and 192.128.0.0/9 in a routing table, each binary expression is like the following. And this table contains the gateway that associates with the subnet.

Subnet	Subnet Binary	Gateway
10.0.0.0/8	00001010 00000000 00000000 00000000	GW1
192.0.0.0/8	11000000 00000000 00000000 00000000	GW2
192.128.0.0/9	11000000 10000000 00000000 00000000	GW3

The bold section is the address that is applied subnet mask. And the trie-tree becomes like the following by building according to the masked addresses:

                 R
                / \
              /     \
            0         1
           /           \
          0             1
         /             /
        0             0
       /             /
      0             0
       \           /
        1         0
       /         /
      0         0
       \       /
        1     0
       /     /
 GW1 [0]   [0] GW2
             \
             [1] GW3

† R: Root Node
†† [n]: Terminal Node

and then it derives the following result by matching the binary target addresses to this tree as much as longer (the digit surrounded by [ ] describes a terminal node):

Target IP	Target IP Binary	Found Gateway
10.10.10.10	0000101[0] 00001010 00001010 00001010	GW1
192.10.10.10	1100000[0] 00001010 00001010 00001010	GW2
192.192.10.10	11000000 [1]1000000 00001010 00001010	GW3
127.0.0.1	01111111 00000000 00000000 00000001	N/A

go-iprtb implements the tree-based algorithm, then it succeeds to improve the performance:

$ go test -bench=. -benchmem
goos: linux
goarch: amd64
pkg: github.com/moznion/go-iprtb
cpu: 12th Gen Intel(R) Core(TM) i7-1280P
Benchmark_PrefixTreeAlgorithm-20        18535410                81.68 ns/op           64 B/op          1 allocs/op
Benchmark_LinearSearch-20                6148155               192.1 ns/op            96 B/op          1 allocs/op
PASS
ok      github.com/moznion/go-iprtb     2.968s

Yay 🎉

ts-dynamodb-attributes-transformer: A code transformer of TypeScript object to DynamoDB attributes

moznion — Mon, 17 Oct 2022 06:14:14 +0000

I published "ts-dynamodb-attributes-transformer" that transforms the TypsScript object to Amazon DynamoDB attributes (precisely, this attributes type is Record<string, AttributeValue> that is defined at aws-sdk-js-v3):

https://github.com/moznion/ts-dynamodb-attributes-transformer

And this is also available on npm:

https://www.npmjs.com/package/@moznion/ts-dynamodb-attributes-transformer

ts-dynamodb-attributes-transformer is a code transformer plugin that uses TypeScript Compiler API.

Let's see how this transformer works.
When it gives the following TypeScript code to this transformer,

import { AttributeValue } from '@aws-sdk/client-dynamodb';
import { dynamodbRecord } from '@moznion/ts-dynamodb-attributes-transformer';

interface User {
  readonly id: number;
  readonly name: string;
  readonly tags: Map<string, string>;
}

const record: Record<keyof User, AttributeValue> = dynamodbRecord<User>({
  id: 12345,
  name: 'John Doe',
  tags: new Map<string, string>([
    ['foo', 'bar'],
    ['buz', 'qux'],
  ]),
});

This transformer detects dynamodbRecord<T>(obj: T) (in this case that is dynamodbRecord<User>(...)) function invocation and analyzes the fields definition of the type parameter T (in this case User), and it generates the JavaScript code like the following according to the T-typed object given as a parameter.

const record = function (arg) {
    return {
        id: {
            N: arg.id.toString()
        },
        name: {
            S: arg.name
        },
        tags: {
            M: function () {
                var m;
                m = {}
                for (const kv of arg.tags) {
                    m[kv[0]] = { S: kv[1] }
                }
                return m;
            }()
        }
    };
}({
    id: 12345,
    name: 'John Doe',
    tags: new Map([
        ['foo', 'bar'],
        ['buz', 'qux'],
    ]),
});

This behavior is like it replaces dynamodbRecord<T>(obj: T) invocation with a generator function for DynamoDB attributes entirely.

As I noted above, this is a TypeScript transformer plugin so it needs to hook this plugin on TypeScript compilation phase. I suppose one of the easiest ways is using ttypescript which is a custom TypeScript compiler that can hook the transformer plugin on a compilation. Please refer also to the "How to use this transformer" section in README.

Naturally, this plugin can transform a target object to the DynamoDB attributes according to the type definition of that object. And this uses TypeScript Compiler API to transform the code thus it can determine the code to generate on compilation statically so it doesn't have to do reflection or something on the fly to construct the DynamoDB attributes object. This contributes to good performance.

The benchmark result between this project and kayomarz/dynamodb-data-types is the following:

node version: v16.17.0
dynamodb-data-types marshalling x 3,475,450 ops/sec ±0.45% (96 runs sampled)
ts-dynamodb-attributes-transformer marshalling x 13,405,409 ops/sec ±0.43% (91 runs sampled)
Fastest is ts-dynamodb-attributes-transformer marshalling

This shows this transformer is about 3.85 times faster than the dynamodb-data-types.

At this moment, this plugin satisfies my use case but I would appreciate your suggestions if you have some enhancement ideas or find any issues!

Published go-optional: Go's Generics friendly optional/option type library

moznion — Thu, 18 Nov 2021 15:19:33 +0000

I've published go-optional, which is a library that provides Go's Generics friendly option/optional type functions.

moznion / go-optional

A library that provides Go Generics friendly "optional" features.

This library provides "typed option" by using generics, it implies this would be a replacement of "nil checking" for the purpose of value existence inspection. This has the pros of strong typing.

You can see the basic usage of this in the synopsis and examples.
Currently, this brings the following utility option functions:

IsSome()
IsNone()
Take()
TakeOr()
TakeOrElse()
Filter()
Map()
MapOr()
Zip()
ZipWith()
Unzip()
UnzipWith()

This library uses Go's under-developing feature "Generics", so if you'd like to try this library, you may have to use the edge of go runtime at this moment (i.e Nov 18, 2021). I suppose gotip would help you to get and install the latest go runtime.
Also you can try this on The Go Playground for gotip: https://gotipplay.golang.org/p/mWGdFIfcK8c

Unfortunately, the Go compiler prohibits putting type parameters on a method so far. For example:

type Something struct {
}

func (s *Something) Echo[V any](v V) V {
    return v
}

at the first glance, this code seems valid syntactically but...

./main.go:6:25: methods cannot have type parameters
./main.go:6:26: invalid AST: method must have no type parameters

the compiler raises the compiling error like the above. This means a method (i.e. a function that has a receiver) cannot have type parameters at present.
Actually, there is a workaround for this by transforming a method to a function like a bellow:

func Echo[V any](s *Something, v V) V {
    return v
}

Therefore, some features (e.g. Map()) are implemented as the function instead of the method in this library.

I wrote this library for my learning the Generics features then I felt Go Generics is almost production-ready, and I believe this library would be also useful :)

Enjoy!

Released radius-rs: an async/await native RADIUS implementation for Rust

moznion — Sun, 13 Dec 2020 09:02:57 +0000

I've published an implementation of the RADIUS server and client for Rust.

moznion / radius-rs

An async/await native implementation of the RADIUS server and client for Rust.

And this is also available on crates.io: https://crates.io/crates/radius

RADIUS is one of the major protocols for AAA (Authentication, Authorization and Accounting). According to the Wikipedia article:

Remote Authentication Dial-In User Service (RADIUS) is a networking protocol, operating on ports 1812 and 1813, that provides centralized Authentication, Authorization, and Accounting (AAA or Triple A) management for users who connect and use a network service.

This library aims to provide the functions of that protocol for Rust programming language.

The feature of this implementation is async/await native functions powered by tokio.
And this implementation and design is based on layeh/radius, this is a RADIUS implementation for golang, so it can generate the Rust code to make the RADIUS applications by giving the dictionary files of FreeRADIUS.

A simple example for the server and client is here:

✨

Please use this library when you implement the RADIUS application in Rust!
And if you have some troubles, questions and etc on this library, please feel free to open an issue.

Enjoy!