feat: ts types, github ci and clean up

[hugomrdias]

• add ts types with jsdocs and aegir
• remove travis and add github action
• update deps and repo clean up (readme, package.json, etc.. )

[vasco-santos]

Mostly good. Just minor things to be fixed

[vasco-santos]

Return types are inferred from the interface. However, it would probably be helpful to have them in the code, special for returning promises. What do you think?

[Gozala]

Or maybe interface should be changed to has(key:Key, options?:Options): Await<boolean> instead so wrapping in promise is unnecessary ?

[hugomrdias]

@Gozala for that we would need to make it an async function
@vasco-santos i would like to avoid writing all the return types if they are already well inferred

[Gozala]

@Gozala for that we would need to make it an async function

I don't believe that's accurate, in fact that was the whole point of Await type. Here is an example:

type Await<T> = Promise<T> | T

interface Key {
    toString():string
}

interface Has {
    has(key:Key, options?:{signal?: AbortSignal}):Await<boolean>
}

class Store implements Has {
    has(key:Key, options:{signal?: AbortSignal}):Await<boolean> {
        if (key.toString().startsWith('http://')) {
          return fetch(key.toString()).then(response => response.ok)
        } else {
            return false
        }
    }
}

[achingbrain]

As a pattern I think Await<T> is something we should allow. The idea of the return type being variable is a bit weird, but in the past we've desired the ability to not create artificial asynchronicity for super-hot codepaths, the idea being you'd look at the return type and resolve the promise if it's a thenable.

Though it's not something we should be doing everywhere, blindly awaiting will be fine 99.9% of the time, unless some rigorous profiling has identified a bottleneck.

[achingbrain]

It does make the error handling for the caller a bit Zalgo harder to handle, mind:

async function derp (input) {
  if (input % 2 === 1) {
    throw new Error('Input was odd')
  }

  return Promise.reject(new Error('Input was even'))
}

const res1 = derp(1) // throws immediately

const res2 = derp(2)

// maybe do some other stuff

await res2 // throws here instead

[hugomrdias]

what do you think we should do here ?

[Gozala]

Looks good! Mostly provided some minor suggestions, I do however would like type-check succeed here instead of failing due to lack of generated types.

[vasco-santos]

LGTM!

[Gozala]

Recent changes seem to have updated all the import paths from interface-datastore/src/* to interface-datastore/dist/src/*. I do not know if that is deliberate, but I do think it's great as it is going to be confusing.