How to create a command

klayr generate:command hello createHello

├── bin/
├── config/
├── src/
│    ├── app/
│    │    ├── app.ts
│    │    ├── index.ts
│    │    ├── modules/
│    │    │   └── hello/
│    │    │      ├── commands/ (1)
│    │    │      │     └──  create_hello_command.ts (2)
│    │    │      ├── endpoint.ts
│    │    │      ├── events/
│    │    │      ├── method.ts
│    │    │      ├── module.ts
│    │    │      └── stores/
│    │    ├── modules.ts
│    │    ├── plugins/
│    │    └── plugins.ts
│    └── commands/
└── test/
    ├── integration/
    ├── network/
    └── unit/
        ├── modules/
        │    └── hello/
        │       ├── commands/
        │       │     └──  create_hello_command.ts (3)
        │       └── modules.spec.ts
        └── plugins/

import { CreateHelloCommand } from "./commands/create_hello_command";
// [...]
export class HelloModule extends BaseModule {
    // [...]
	public commands = [new CreateHelloCommand(this.stores, this.events)];
    // [...]
}

import { Modules, StateMachine } from 'klayr-sdk';

interface Params {
}

export class CreateHelloCommand extends Modules.BaseCommand {
	public schema = {
		$id: 'CreateHelloCommand',
		type: 'object',
		properties: {},
	};

	// eslint-disable-next-line @typescript-eslint/require-await
	public async verify(_context: StateMachine.CommandVerifyContext<Params>): Promise<StateMachine.VerificationResult> {
		return { status: StateMachine.VerifyStatus.OK };
	}

	public async execute(_context: StateMachine.CommandExecuteContext<Params>): Promise<void> {
	}
}

interface Params {
	message: string;
}

export const createHelloSchema = {
	$id: 'hello/createHello-params',
	title: 'CreateHelloCommand transaction parameter for the Hello module',
	type: 'object',
	required: ['message'],
	properties: {
		message: {
			dataType: 'string',
			fieldNumber: 1,
			minLength: 3,
			maxLength: 256,
		},
	},
};

import { createHelloSchema } from '../schema';
// [...]
export class CreateHelloCommand extends Modules.BaseCommand {
    public schema = createHelloSchema;
    // [...]
}

import { ModuleConfig } from '../types';
// [...]

export class CreateHelloCommand extends Modules.BaseCommand {
    public schema = createHelloSchema;
	private _blacklist!: string[];

    public async init(config: ModuleConfig): Promise<void> {
		// Set _blacklist to the value of the blacklist defined in the module config
		this._blacklist = config.blacklist;
		// Set the max message length to the value defined in the module config
		this.schema.properties.message.maxLength = config.maxMessageLength;
		// Set the min message length to the value defined in the module config
		this.schema.properties.message.minLength = config.minMessageLength;
	}
    // [...]
}

// [...]
export class HelloModule extends Modules.BaseModule {
    // [...]
    public async init(args: Modules.ModuleInitArgs): Promise<void> {
        // Get the module config defined in the config.json file
        const { moduleConfig } = args;
        // Overwrite the default module config with values from config.json, if set
        const config = utils.objects.mergeDeep({}, defaultConfig, moduleConfig) as ModuleConfigJSON;
        // Validate the provided config with the config schema
        validator.validate<ModuleConfigJSON>(configSchema, config);
        // Call the command init() method with config as parameter
        this.commands[0].init(config).catch(err => {
            console.log("Error: ", err);
        });
    }
    // [...]
}

// [...]
export class CreateHelloCommand extends Modules.BaseCommand {
    public schema = createHelloSchema;
    private _blacklist!: string[];

    public async init(config: ModuleConfig): Promise<void> {
        // [...]
    }

    public async verify(context: StateMachine.CommandVerifyContext<Params>): Promise<StateMachine.VerificationResult> {
        let validation: StateMachine.VerificationResult;
        const wordList = context.params.message.split(" ");
        const found = this._blacklist.filter(value => wordList.includes(value));
        if (found.length > 0) {
            context.logger.info("==== FOUND: Message contains a blacklisted word ====");
            throw new Error(
                `Illegal word in hello message: ${  found.toString()}`
            );
        } else {
            context.logger.info("==== NOT FOUND: Message contains no blacklisted words ====");
            validation = {
                status: StateMachine.VerifyStatus.OK
            };
        }
        return validation;
    }
    // [...]
}

import { Modules, StateMachine } from 'klayr-sdk';
import { createHelloSchema } from '../schema';
import { MessageStore } from '../stores/message';
import { counterKey, CounterStore, CounterStoreData } from '../stores/counter';
import { ModuleConfig } from '../types';
import { NewHelloEvent } from '../events/new_hello';

export class CreateHelloCommand extends Modules.BaseCommand {
    public schema = createHelloSchema;
    private _blacklist!: string[];
    public async init(config: ModuleConfig): Promise<void> {
        // [...]
    }

	// eslint-disable-next-line @typescript-eslint/require-await
    public async verify(context: StateMachine.CommandVerifyContext<Params>): Promise<StateMachine.VerificationResult> {
        // [...]
    }

    public async execute(context: StateMachine.CommandExecuteContext<Params>): Promise<void> {
        // 1. Get account data of the sender of the Hello transaction.
        const { senderAddress } = context.transaction;
        // 2. Get message and counter stores.
        const messageSubstore = this.stores.get(MessageStore);
        const counterSubstore = this.stores.get(CounterStore);

        // 3. Save the Hello message to the message store, using the senderAddress as key, and the message as value.
        await messageSubstore.set(context, senderAddress, {
            message: context.params.message,
        });

        // 3. Get the Hello counter from the counter store.
        let helloCounter: CounterStoreData;
        try {
            helloCounter = await counterSubstore.get(context, counterKey);
        } catch (error) {
            helloCounter = {
                counter: 0,
            }
        }
        // 5. Increment the Hello counter +1.
        helloCounter.counter+=1;

        // 6. Save the Hello counter to the counter store.
        await counterSubstore.set(context, counterKey, helloCounter);

        // 7. Emit a "New Hello" event
        const newHelloEvent = this.events.get(NewHelloEvent);
        newHelloEvent.add(context, {
            senderAddress: context.transaction.senderAddress,
            message: context.params.message
        },[context.transaction.senderAddress]);
    }
}