cue言語でOpenAPIのYAMLファイルを生成したい

openapi: 3.0.0
# Incorrect!
info:
  $ref: info.yaml
paths:
  $ref: paths.yaml

paths:
  /users:
    $ref: '../resources/users.yaml'
  /users/{userId}:
    $ref: '../resources/users-by-id.yaml'

brew install cue-lang/tap/cue 

hello: {
	world: "hoge"
}

cue export main.cue --out yaml
hello:
  world: hoge

hello: {
	// comment
	world: "hoge"
}

hello: {
	world: "hoge"
}

hello: {
	hoge: "fuga"
}

cue export main.cue --out yaml
hello:
  world: hoge
  hoge: fuga

foo: {
	bar: "hoge"
}


hello: {
	world: foo.bar
}

foo:
  bar: hoge
hello:
  world: hoge

let A = a
a: {
	d: 3
}
b: {
	a: {
		c: A.d
	}
}

a:
  d: 3
b:
  a:
    c: 3

#Task: {
	name: string
	rank: int
}

go_to_park: #Task & {
	name: "公園に行く"
	rank: 1
}

go_to_park:
  name: 公園に行く
  rank: 1

#Task: {
	name: string
	rank: int
}

go_to_park: #Task & {
	name: "公園に行く"
	rank: "error"
}

go_to_park.rank: conflicting values int and "error" (mismatched types int and string):
    ./main.cue:3:8
    ./main.cue:8:8

#Task: {
	name: string
	rank: int
}

go_to_park: #Task & {
	name: "公園に行く"
}

go_to_park.rank: incomplete value int:
    ./main.cue:3:8

#Task: {
	name: string
	rank: int
}

go_to_park: #Task & {
	name: "公園に行く"
}

go_to_park: {
	rank: 3
}

go_to_park:
  name: 公園に行く
  rank: 3

#Task: {
	name: string
	rank: int
}

go_to_park: #Task & {
	name: "公園に行く"
}

go_to_park: {
	rank: 3
}

go_to_park: {
	rank: 4
}

go_to_park.rank: conflicting values 4 and 3:
    ./main.cue:11:8
    ./main.cue:15:8

#Task: {
	name: string
	rank?: int
}

go_to_park: #Task & {
	name: "公園に行く"
}

go_to_park:
  name: 公園に行く

#Task: {
	name: "公園に行く" | "買い物に行く"
	rank: int
}

go_to_park: #Task & {
	name: "公園に行く"
	rank: 1
}

go_to_shopping: #Task & {
	name: "買い物に行く"
	rank: 2
}

go_to_park:
  name: 公園に行く
  rank: 1
go_to_shopping:
  name: 買い物に行く
  rank: 2

#Task: {
	name: "公園に行く" | "買い物に行く"
	rank: int
}

go_to_park: #Task & {
	name: "公園に行く"
	rank: 1
}

go_to_shopping: #Task & {
	name: "買い物に行く"
	rank: 2
}

go_to_mountain: #Task & {
	name: "山に行く"
	rank: 3
}

go_to_mountain.name: 2 errors in empty disjunction:
go_to_mountain.name: conflicting values "公園に行く" and "山に行く":
    ./main.cue:2:8
    ./main.cue:16:17
    ./main.cue:17:8
go_to_mountain.name: conflicting values "買い物に行く" and "山に行く":
    ./main.cue:2:28
    ./main.cue:16:17
    ./main.cue:17:8

#Task: {
	name: string
	rank: int | *1
}

go_to_park: #Task & {
	name: "公園に行く"
}

go_to_park:
  name: 公園に行く
  rank: 1

#Task: {
	name: string
         // int かつ、1以上、100以下、デフォルトは1
	rank: int & >=1 & <=100 | *1
}

go_to_park: #Task & {
	name: "公園に行く"
	rank: 101
}

go_to_park.rank: 2 errors in empty disjunction:
go_to_park.rank: conflicting values 1 and 101:
    ./main.cue:3:29
    ./main.cue:6:13
    ./main.cue:8:8
go_to_park.rank: invalid value 101 (out of bound <=100):
    ./main.cue:3:20
    ./main.cue:8:8

#Task: {
	name: string
	rank: uint8 & >=1 | *1
}

go_to_park: #Task & {
	name: "公園に行く"
	rank: 256
}

go_to_park.rank: 2 errors in empty disjunction:
go_to_park.rank: conflicting values 1 and 256:
    ./main.cue:3:23
    ./main.cue:6:13
    ./main.cue:8:8
go_to_park.rank: invalid value 256 (out of bound <=255):
    ./main.cue:8:8

task: [Name=string]: {
  name: Name
  rank: uint8 & >=1 | *1
  description: string | *""
}

task: 公園に行く: rank: 2
task: 公園に行く: description: "長岡京公園"

task: 買い物に行く: rank: 3

task:
  公園に行く:
    name: 公園に行く
    rank: 2
    description: 長岡京公園
  買い物に行く:
    name: 買い物に行く
    rank: 3
    description: ""

a: {
  message: "This is message"
}

a: {
  hello: "world"
}

 cue export a.cue b.cue --out yaml

a:
  message: This is message
  hello: world

package main

a: {
}

package main

b: {
}

 cue export .  --out yaml

a: {}
b: {}

package main2

c: {
}

found packages "main" (a.cue) and main2 (c.cue) in "/foo/bar"

import "net"

ipv4: net.IPv4
ipv4: "256.1.1.1"

ipv4: invalid value "256.1.1.1" (does not satisfy net.IPv4):
    ./a.cue:3:7
    ./a.cue:4:7

import "math"

pi: math.Pi

pi: 3.14159265358979323846264338327950288419716939937510582097494459

import "list"

sum: list.Sum([1, 2, 3, 4, 5])

sum: 15

cue mod init [モジュール名]

.
└── cue.mod
    ├── module.cue
    ├── pkg
    └── usr

3 directories, 1 file

package bar

bar: {
  hello: "world"
}

package root

#  module名/パッケージ名(パス)
import "example.com/foo/bar"

// bar パッケージから、bar 構造体を呼び出しておく
bar.bar

# root.cue と cue.mod のあるディレクトリで以下を実行
cue export root.cue --out yaml

hello: world

package something

something: {
}

package root

import "bucyou.net/something"

// something.something => {}
something.something

// Title
$version: "1.0"

// Info describes...
#Info: {
    // Name of the adapter.
    name: string

    // Templates.
    templates?: [...string]

    // Max is the limit.
    max?: uint & <100
}

{
   "openapi": "3.0.0",
   "info": {
      "title": "Title",
      "version": "1.0"
   },
   "paths": {},
   "components": {
      "schemas": {
         "Info": {
            "description": "Info describes...",
            "type": "object",
            "required": [
               "name"
            ],
            "properties": {
               "name": {
                  "description": "Name of the adapter.",
                  "type": "string"
               },
               "templates": {
                  "description": "Templates.",
                  "type": "array",
                  "items": {
                     "type": "string"
                  }
               },
               "max": {
                  "description": "Max is the limit.",
                  "type": "integer",
                  "minimum": 0,
                  "maximum": 100,
                  "exclusiveMaximum": true
               }
            }
         }
      }
   }
}

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"os"

	"cuelang.org/go/cue"
	"cuelang.org/go/cue/load"
	"cuelang.org/go/encoding/openapi"
)

func main() {
	err := openAPISchemas(os.Args[1:])
	if err != nil {
		fmt.Println(err)
	}
}

func openAPISchemas(entrypoint []string) error {
	// get cue instance
	bis := load.Instances(entrypoint, nil)
	insts := cue.Build(bis)
	for _, inst := range insts {
		b, err := openapi.Gen(inst, nil)
		if err != nil {
			return err
		}

		var out bytes.Buffer
		err = json.Indent(&out, b, "", "   ")
		if err != nil {
			return err
		}

		fmt.Println(string(out.Bytes()))
	}

	return nil
}

go mod init bucyou.net/cue_to_openapi
go mod tidy
go run main.go a.cue
# 先程、例示したJSONデータが表示される

#a: {
  foo: _
}

a: #a & {
  foo: "OK"
}

b: #a & {
  foo: 3.14
}

c: #a & {
  foo: {
    something: "any string"
  }
}

a:
  foo: OK
b:
  foo: 3.14
c:
  foo:
    something: any string

#a: [int]

a: #a & [1]

a:
  - 1

#a: [int]

a: #a & [1, 2]

a: incompatible list lengths (1 and 2)

#a: [...int]

a: #a & [1, 2]

a:
  - 1
  - 2

import "list"

#a: [...int] & list.MaxItems(2)

a: #a & [1, 2]

import "list"

#a: [...int] & list.MaxItems(2)

a: #a & [1, 2, 3]

a: invalid value [1,2,3] (does not satisfy list.MaxItems(2)):
    -:3:16
    -:3:30
    -:5:4

#a: {
  [string]: {
    name: string
  }
}

a: #a & {
  "Kawahara": {
    name: "Kawahara"
  }
  "Yamada": {
     name: "Yamada"
  }
}

a:
  Kawahara:
    name: Kawahara
  Yamada:
    name: Yamada

#a: {
  [string]: {
    name: string
  }
}

#a: [string]: name: string

#type_a: {
  type: "a"
  description: string
}

#type_b: {
  type: "b"
  description: string
  url: string
}

#type: #type_a | #type_b

my_type: #type & {
  type: "b"
  description: "This is b type (url is required)"
  url: "http://www.bucyou.net"
}

my_type:
  type: b
  description: This is b type (url is required)
  url: http://www.bucyou.net

#type_a: {
  type: "a"
  description: string
}

#type_b: {
  type: "b"
  description: string
  url: string
}

#type: #type_a | #type_b

my_type: #type & {
  type: "b"
  description: "This is b type (url is required)"
}

my_type.url: incomplete value string:
    -:9:8

cue mod init "bucyou.net/openapi"

.
└── cue.mod
    ├── module.cue  # module: "bucyou.net/openapi"
    ├── pkg
    └── usr

.
├── component
│   └── schema
│       └── user.cue
├── cue.mod
│   ├── module.cue
│   ├── pkg
│   └── usr
├── definition
│   └── openapi.cue
├── path
│   └── users.cue
└── root.cue

package schema

import "bucyou.net/openapi/definition"

User: definition.#schema & {
	type: "object"
	properties: {
		id: {
			type: "string"
			description: "uuidv4 format"
			readOnly: true
		},
		name: {
			type: "string"
			description: "user name"
		}
		email: {
			type: "string"
			description: "user email"
		}
	}
	required: [
		"id",
		"name",
		"email"
	]
}

package path

import "bucyou.net/openapi/definition"

"/users": definition.#path & {
	get: {
		tags: ["Users"]
		summary: "List users"
		security: [
			{
				OAuth2: ["read"]
			}
		]
		responses: {
			"200": {
				description: "Successful operation"
				content: {
					"application/json": {
						schema: {
							type: "array"
							items: {
								$ref: "#/components/schemas/User"
							}
						}
					}
				}
			}
		}
	}
}

"/users/{id}": definition.#path & {
	get: {
		tags: ["Users"]
		summary: "Get a user"
		security: [
			{
				OAuth2: ["read"]
			}
		]
		parameters: [
			{
				name:        "id"
				in:          "path"
				description: "User Id"
				required:    true
				schema: {
					type: "string"
				}
			},
		]
		responses: {
			"200": {
				description: "Successful operation"
				content: {
					"application/json": {
						schema: {
							$ref: "#/components/schemas/User"
						}
					}
				}
			}
		}
	}
}

package root

// bucyou.net/openapi が プロジェクトルートのパスとして扱われる
import (
	"bucyou.net/openapi/path"
	"bucyou.net/openapi/definition"
	"bucyou.net/openapi/component/schema"
)

// definition.#opanapi は、definition/openapi.cue で定義されている
// openapi のバージョンは 3.0.3 で定義済みなので、ここで記載する必要はない
definition.#openapi & {
	info: {
		title:   "The sample API"
		version: "0.0.1"
	}
	servers: [
		{
			url:         "http://localhost:3000/v1"
			description: "local server"
		},
	]
        // ipmort した path パッケージを使う
	paths: path
	components: {
                 // import した component/schema パッケージを使う
		schemas: schema
		securitySchemes: {
			OAuth2: {
				type: "oauth2"
				flows: {
					authorizationCode: {
						authorizationUrl: "https://example.com/oauth/authorize"
						tokenUrl: "https://example.com/oauth/token"
						scopes: {
							read: "Grants read access"
							write: "Grants write access"
							admin: "Grants all access"
						}
					}
				}
			}
		}
	}
}

openapi: 3.0.3
info:
  title: The sample API
  version: 0.0.1
servers:
  - url: http://localhost:3000/v1
    description: local server
paths:
  /users:
    get:
      tags:
        - Users
      summary: List users
      security:
        - OAuth2:
            - read
      responses:
        "200":
          description: Successful operation
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/User'
  /users/{id}:
    get:
      tags:
        - Users
      summary: Get a user
      security:
        - OAuth2:
            - read
      parameters:
        - name: id
          in: path
          description: User Id
          required: true
          schema:
            type: string
      responses:
        "200":
          description: Successful operation
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/User'
components:
  schemas:
    User:
      type: object
      properties:
        id:
          type: string
          description: uuidv4 format
          readOnly: true
        name:
          type: string
          description: user name
        email:
          type: string
          description: user email
      required:
        - id
        - name
        - email
  securitySchemes:
    OAuth2:
      type: oauth2
      flows:
        authorizationCode:
          authorizationUrl: https://example.com/oauth/authorize
          tokenUrl: https://example.com/oauth/token
          scopes:
            read: Grants read access
            write: Grants write access
            admin: Grants all access

package path

#oauth2_read: {
	OAuth2: ["read"]
}

#oauth2_write: {
	OAuth2: ["write"]
}

package path

import "bucyou.net/openapi/definition"

"/users": definition.#path & {
	get: {
		tags: ["Users"]
		summary: "List users"
		security: [#oauth2_read]
		responses: {
			"200": {
				description: "Successful operation"
				content: {
					"application/json": {
						schema: {
							type: "array"
							items: {
								$ref: "#/components/schemas/User"
							}
						}
					}
				}
			}
		}
	}
}

// 以下省略