atom-holochain-snippets

Atom package for Holochain snippets (hdk-rust)

Install

Snippets:

hclib

Default crate imports for main lib.rs file

#![feature(try_from)]
#[macro_use]
extern crate hdk;
extern crate serde;
#[macro_use]
extern crate serde_derive;
extern crate serde_json;
#[macro_use]
extern crate holochain_core_types_derive;

use hdk::{
    entry_definition::ValidatingEntryType,
    error::ZomeApiResult,
};

use hdk::holochain_core_types::{
    cas::content::Address,
    entry::Entry,
    dna::entry_types::Sharing,
    error::HolochainError,
    json::JsonString,
    validation::EntryValidationData
};

hcmod

Default crate imports for modules where you define application logic

use hdk::{
    self,
    error::{ZomeApiError, ZomeApiResult},
    holochain_core_types::{
        cas::content::Address,
        dna::capabilities::CapabilityRequest,
        entry::{cap_entries::CapabilityType, entry_type::EntryType, Entry},
        error::HolochainError,
        json::JsonString,
        signature::{Provenance, Signature},
    },
    holochain_wasm_utils::api_serialization::{
        commit_entry::CommitEntryOptions,
        get_entry::{
            EntryHistory, GetEntryOptions, GetEntryResult, GetEntryResultType, StatusRequestKind,
        },
        get_links::{GetLinksOptions, GetLinksResult},
        QueryArgsOptions, QueryResult,
    },
    AGENT_ADDRESS, AGENT_ID_STR, CAPABILITY_REQ, DNA_ADDRESS, DNA_NAME, PROPERTIES, PUBLIC_TOKEN,
};

hczome

define_zome! macro

define_zome! {
    entries: [
        $1
    ]
    
    genesis: || {
        Ok(())
    }
    
    functions: [
    
    ]
    
    traits: {
        hc_public [
        
        ]
    }
}

hcdef

definition()

pub fn definition() -> ValidatingEntryType {
    $1
}

hcentry

entry! macro

entry!(
    name: ${1:"myentry"},
    description: ${2:"description"},
    sharing: Sharing::${3:Public},
    validation_package: || {
        hdk::ValidationPackageDefinition::${4:Entry}
    },
    validation: |_validation_data: ValidationData<${5:EntryType}>| {
        ${6:Ok(())}
    },
    links: [
        $7
    ]
)

hcfun

zome function

${1:my_function_name}: {
    inputs: | $2 |,
    outputs: | $3 |,
    handler: handle_${1:my_function_name}
}

hclink

link! macro

link!(
    hdk::LinkDirection::${1:From},
    ${2:"%agent_id"},
    link_type: ${3:"my_link_type"},
    validation_package: || {
        hdk::ValidationPackageDefinition::${4:ChainFull}
    },
    validation: | _validation_data: hdk::LinkValidationData | {
        ${5:Ok(())}
    }
)

hcfrom

from! macro

from!(
    ${1:"%agent_id"},
    link_type: ${2:"my_link_type"},
    validation_package: || {
        hdk::ValidationPackageDefinition::${3:ChainFull}
    },
    validation: | _validation_data: hdk::LinkValidationData | {
        ${4:Ok(())}
    }
)

hcto

to! macro

to!(
    ${1:"entry_name"},
    link_type: ${2:"my_link_type"},
    validation_package: || {
        hdk::ValidationPackageDefinition::${3:ChainFull}
    },
    validation: | _validation_data: hdk::LinkValidationData | {
        ${4:Ok(())}
    }
)

hcstruct

new entry struct + impl

#[derive(Serialize, Deserialize, Debug, DefaultJson)]
struct ${1:MyEntryType} {
    ${2:my_field}: String
}

impl ${1:MyEntryType} {
    pub fn new(${2:my_field}: &str) -> ${1:MyEntryType} {
        ${1:MyEntryType} {
            ${2:my_field}: ${2:my_field}.to_owned()
        }
    }
    
    pub fn ${2:my_field}(&self) -> String {
        self.${2:my_field}.clone()
    }
}

hccreate

basic create entry function

fn handle_create_${1:my_entry}(${2:my_field}: String) -> ZomeApiResult<Address> {
    let address = hdk::commit_entry(Entry::App("${1:my_entry}".into(), ${3:MyEntryType}::new(&${2:my_field}, "now").into()))?;
    Ok(address)
}

hcget

basic get entry function

fn handle_get_${1:my_entry}(${1:my_entry}_address: Address) -> ZomeApiResult<Option<Entry>> {
    hdk::get_entry(&${1:my_entry}_address)
}

hcupdate

basic update entry function

fn handle_update_${1:my_entry}(${1:my_entry}_address: Address, new_content: ${3:String}) -> ZomeApiResult<Address> {
    let updated_${1:my_entry} = Entry::App(
        "${1:my_entry}".into(),
        ${2:MyEntryType}::new(&new_content).into(),
    );
    hdk::update_entry(updated_${1:my_entry}, &${1:my_entry}_address)
}

hcdelete

basic delete entry function

fn handle_delete_${1:my_entry}(${1:my_entry}_address: Address) -> ZomeApiResult<Address> {
    hdk::get_entry(&${1:my_entry}_address)?;
    hdk::remove_entry(&${1:my_entry}_address)
}

hcsend

basic send payload function

fn handle_send_${1:my_payload}(to_agent: Address, payload: ${2:String}) -> ZomeApiResult<String> {
    hdk::send(to_agent, payload, ${3:60000}.into())
}