Proposal: Builder Pattern Alternatives

[KwilLuke]

Below is a proposed approach for how the public APIs in Kwil-JS can look to move away from the Builder Patterns and more closely resemble what is available in packages like EtherJS and Viem.

1. Create KwilSigner Class

Create a Kwil Signer Class that is used to signing transactions and call requests:

const mySigner = new KwilSigner(
     publicKey: string, 
     signer: EthersSigner | (msg: Uint8Array) => Uint8Array, 
     signatureType?: string
)

signatureType is required to be specified if it does not receive an EtherJS signer.

2. Create four new methods on the main kwil class

Currently, the entry point for KwilJS is with the WebKwil or NodeKwil class:

e.g.

const kwil = new WebKwil({
   kwilProvider: "https://provider.kwil.com",
   chainId: "your_chain_id",
});

Action Operations - kwil.call() and kwil.execute()

For action-related operations (state-changing and view actions), there will be two methods:

• kwil.call(actionPayload: ActionInterface, signer?: KwilSigner) - Executes view actions. Signer only required if the action has must_sign.
• kwil.execute(actionPayload: ActionInterface, signer: KwilSigner) - Executes mutative actions. Signer is required.

TheActionInterface for both methods will look like this:

interface ActionInterface {
     dbid: string,
     action: string,
     inputs?: Array<objects> | Array<ActionInput>,
     description?: string
}

Database Operations - kwil.deploy() and kwil.drop()

For deploying and dropping databases, there will be two methods:

• kwil.deploy(deployPayload: DeployInterface, signer: KwilSigner) - Used to deploy a database.
• kwil.drop(dropPayload: DropInterface, signer: KwilSigner) - Used to drop a database.

With the following respective interfaces:

interface DeployInterface {
     schema: object<CompiledKuneiform>,
     description?: string
}

interface DropInterface {
     dbid: string,
     description?: string
}

[Yaiba]

I feel the awkwardness to create the KwilSigner comes from:

• need public key
• need to allow developer to use existing Ethersjs signer

Overall it looks good to me, we can try the DX constructing KwilSigner like proposed, if we need to change, it will still works with the rest of the methods.

[KwilLuke]

@Yaiba,

I have completed a first implementation of what I described in this issue (in commit aca229d).

Here is what the developer experience could look like end to end. In my opinion, the public key thing is quite awkward (when using ethereum / etherjs), but I can't find a way around it. Any thoughts?

const kwil = new NodeKwil({
    kwilProvider: "http://localhost:8080"
})

const provider = new JsonRpcProvider(process.env.ETH_PROVIDER)
const wallet = new Wallet(process.env.PRIVATE_KEY as string, provider)

async function buildSigner() {
    const pk = await Utils.recoverSecp256k1PubKey(wallet);
    return new KwilSigner(pk, wallet);
}

async function main() {
    const signer = await buildSigner();

    // actions
    const actionBody: ActionBody = {
        dbid: 'xd924382720df474c6bb62d26da9aeb10add2ad2835c0b7e4a6336ad8',
        action: 'add_post',
        inputs: [{
            "$id": 69,
            "$user": "Luke",
            "$title": "Test Post",
            "$body": "This is a test post"
        }],
        description: "Add a post"
    }

    // execute
    await kwil.execute(actionBody, signer);

    //call with signer
    await kwil.call(actionBody, signer);

    //call without signer
    await kwil.call(actionBody);

    // deploy database
    const deployBody: DeployBody = {
        schema: compiledKf,
        description: "My first database"
    }

    // deploy
    await kwil.deploy(deployBody, signer);
    
    // drop database
    const dropBody: DropBody = {
        dbid: 'abc123',
        description: "Drop this database"
    }

    // drop
    await kwil.drop(dropBody, signer);
}

cc @brennanjl

[Yaiba]

Can const kwil = new NodeKwil({ kwilProvider: "http://localhost:8080" })
becomes
const kwil = new NodeKwil("http://localhost:8080") ? Feels more direct this way.

[KwilLuke]

As of now, no, because there are other configs that can be passed there (all optional).

e.g.

const kwil = new NodeKwil({
     kwilProvider: 'http://localhost:8080',
     timeout: 10000,
     logging: true
});