zweidenker / openapi Goto Github PK

Currently dateAndTime is handled via formatString but OpenAPI defines it as primitive type

At the moment $ref is handled by pre parsing JSON to detect if the first key is $ref. But this is a wrong assumption. Doing it properly will mean to add a visitor that post-processes the OpenAPI after it is read from JSON

There is no supported to define responses of a call by status code

We are missing enum type like:

#OASchema>>enum: #(this is an enum)

JSON schema defines properties for type and some value formats. The code should be flexible enough so it is possible to define custom constraints and add it to a property. Custom constraints should carry a label that can be added in e.g. the description

we are missing #OASchema>>number

Construction of the request body is too complicated. Should be doable by method, mime type and schema

A unit schema is property value (a number) and property unit (an enum).

Would be useful to define volume Units, distance units etc as json schema. It should be easy to add properties like ranges etc on top

In order to validate/describe outgoing objects Response Object needs to be implemented

Needs to be defined when a read:schema: in the json schema is appropriate and when is the conversion from OpenAPI string done.

Hello and congrats for your project! It seems you are pioneering openapi in Smalltalk :) I would like to try to use your project for both, generating the docs and generating the API code in Smalltalk. Just in case, do you have some base guidelines to generate the code? This is what I did right now (it could be useful for the readme if you think it can help other developers):

1. Use Iceberg to load the repo. It is simpler via https
2. Click on the repo > Metacello > Install baseline
3. You can check the tests, or you can set up a server from the Playground with the example API, and check it from your Web browser:

server := ZnServer startOn: 1700 + 10 atRandom.
server delegate:
(ZnRestServerDelegate new
uriSpace: ( OpenAPIUriSpace new
rootClass: OpenAPICall;
yourself )).

Pet instances add: (Pet new id: 1; name: 'a'; age: 1).
Pet instances add: (Pet new id: 2; name: 'a'; age: 2).

server localUrl. // e.g. Visit http://localhost:1710/pets/01

4. If you want to load your own OpenAPI specification, lets say:
   fileContent := '{ "openapi": "3.0.0", ...}'.

You can do it by loading from a string:
api := OpenAPI fromString: fileContent.

Bue then... I couldn't find the way to generate the supporting classes (e.g. Pet, OpenAPISpecCall, etc). Or is it something we should manually create?

Thanks!

Since the separation of JSON schema and OpenAPI the exception handling is not working as expected. There are new exception from JSON schema that should be caught as well. Most constraint errors or type errors could be automatically translated into 400 status code responses with error description

At the moment we only have JSON schema type and value constraints per property. An additional checking of constraints for the resulting object is needed

OpenAPI has been implemented from scratch as OpenAPI without determine which of the structure is lend from JSON schema. Both should be separated and packaged in separate repositories

When I run:

Metacello new
    baseline: 'OpenAPI';
    repository: 'github://zweidenker/OpenAPI/';
    load.

I am getting what appears to be an Ombu error:

ZnBufferedReadWriteStream(Object)>>doesNotUnderstand: #defaultBufferSize
ZnBufferedReadWriteStream>>on:
ZnBufferedReadWriteStream class>>on:
FileReference>>binaryReadWriteStream
[ | initialPosition initialLocalName fileStream |
self entryBuffer isEmpty
	ifTrue: [ ^ self ].
fileStream := ZnCharacterReadWriteStream
	on: fileReference binaryReadWriteStream
	encoding: #utf8.
[ | anEntryWriter |
fileStream setToEnd.
initialPosition := fileStream position.
initialLocalName := self entryBuffer first value.
anEntryWriter := self newEntryWriter.
[ self entryBuffer isEmpty ]
	whileFalse: [ | next entry |
		next := self entryBuffer removeFirst.
		entry := next key.

		"Write entry to file"
		anEntryWriter on: fileStream nextEntryPut: entry ].

"In Linux it was necessary to explicitely flush the file stream"
fileStream flush.
lastStreamPosition := fileStream size ]
	ensure: [ fileStream close ].
self
	refreshEntryPositionsByLocalNameStartingAt: initialPosition
	since: initialLocalName ] in OmBlockFileStore(OmFileStore)>>flushEntryBuffer in Block: [ | initialPosition initialLocalName fileStream |...
[ caught := true.
self wait.
blockValue := mutuallyExcludedBlock value ] in Semaphore>>critical: in Block: [ caught := true....
BlockClosure>>ensure:
Semaphore>>critical:
OmBlockFileStore(OmFileStore)>>critical:
OmBlockFileStore(OmFileStore)>>flushEntryBuffer
OmDeferrer>>sendMessage
[ self sendMessage ] in OmDeferrer>>flush in Block: [ self sendMessage ]
BlockClosure>>ensure:
OmDeferrer>>flush
[ "Loop until enough time passed since last #schedule"
[ DateAndTime now < (lastSchedule + duration) ]
	whileTrue: [ duration wait ].

"Execute deferred action (if not flushed before) and clean up"
self flush ] in OmDeferrer>>runMessageProcess in Block: [ "Loop until enough time passed since last #sched...etc...
[ self value.
Processor terminateActive ] in BlockClosure>>newProcess in Block: [ self value....

There is a pragma based builder that helps constructing the parameters and request body of an OpenAPI call. Another method is needed to access the path item object itself in order to add descriptions and such

API objects in OpenAPI can be defined in place or referenced via the $ref key. The implementation needs to take care to materialize the right type

Current NeoJSON materialization tries to detect $ref elements directly which does not work. There is now a visitor doing it properly. Left-overs from the old handling need to be removed

Implement allOf: schema type.