Developer Overview

import { BlockHandler, BlockMetadata, ExecutionContext } from "@zzyra/sdk";

export class CustomBlock extends BlockHandler {
  getMetadata(): BlockMetadata {
    return {
      id: "my-custom-block",
      name: "Custom Function",
      description: "My custom automation block",
      category: "custom",
      inputs: [
        {
          name: "inputData",
          type: "string",
          required: true,
          description: "Input data to process",
        },
      ],
      outputs: [
        {
          name: "result",
          type: "object",
          description: "Processed result",
        },
      ],
      configFields: [
        {
          name: "apiKey",
          type: "string",
          label: "API Key",
          required: true,
          description: "External service API key",
        },
      ],
    };
  }

  async execute(
    inputs: any,
    config: any,
    context: ExecutionContext
  ): Promise<any> {
    // Your custom logic here
    const result = await this.processData(inputs.inputData, config.apiKey);

    // Log execution for debugging
    await context.logger.info("Custom block executed successfully", { result });

    return { result };
  }
}

# Install Zzyra SDK
npm install @zzyra/sdk

# Initialize a new block project
npx @zzyra/cli init my-custom-block

# Install dependencies
cd my-custom-block
npm install

# Start development server
npm run dev

my-custom-block/
├── src/
│   ├── index.ts          # Main block implementation
│   ├── types.ts          # TypeScript type definitions
│   └── utils.ts          # Utility functions
├── tests/
│   ├── unit.test.ts      # Unit tests
│   └── integration.test.ts # Integration tests
├── docs/
│   └── README.md         # Block documentation
├── package.json          # Dependencies and scripts
├── tsconfig.json         # TypeScript configuration
└── zzyra.config.js        # Zzyra-specific configuration

import { ethers } from "ethers";

class Web3Block extends BlockHandler {
  async execute(inputs: any, config: any, context: ExecutionContext) {
    // Get Web3 provider for specific chain
    const provider = await context.web3.getProvider("ethereum");

    // Create contract instance
    const contract = new ethers.Contract(
      inputs.contractAddress,
      inputs.abi,
      provider
    );

    // Execute contract call
    const result = await contract[inputs.methodName](...inputs.parameters);

    return { result: result.toString() };
  }
}

class AIBlock extends BlockHandler {
  async execute(inputs: any, config: any, context: ExecutionContext) {
    // Use Zzyra's AI provider
    const aiResponse = await context.ai.generate({
      prompt: inputs.prompt,
      model: config.model || "gpt-4",
      temperature: config.temperature || 0.7,
    });

    return {
      response: aiResponse.text,
      tokens: aiResponse.usage,
    };
  }
}

import { BlockTester, TestCase } from "@zzyra/sdk/testing";

describe("My Custom Block", () => {
  let tester: BlockTester;

  beforeEach(() => {
    tester = new BlockTester(new MyCustomBlock());
  });

  it("should process input correctly", async () => {
    const testCase: TestCase = {
      inputs: { data: "test input" },
      config: { apiKey: "test-key" },
      expectedOutputs: { result: "processed result" },
    };

    const result = await tester.run(testCase);
    expect(result.success).toBe(true);
    expect(result.outputs.result).toBe("processed result");
  });

  it("should handle errors gracefully", async () => {
    const testCase: TestCase = {
      inputs: { data: "invalid input" },
      config: { apiKey: "invalid-key" },
      expectError: true,
    };

    const result = await tester.run(testCase);
    expect(result.success).toBe(false);
    expect(result.error).toBeDefined();
  });
});

# Test your block locally
npm run test

# Run in simulation mode
npm run simulate

# Build for production
npm run build

// Deploy to private Zzyra instance
const deployment = await zzyra.deploy({
  block: new MyCustomBlock(),
  environment: "production",
  access: "private",
  organization: "my-company",
});

// Retry pattern for external API calls
async function withRetry<T>(
  operation: () => Promise<T>,
  maxRetries: number = 3
): Promise<T> {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await operation();
    } catch (error) {
      if (i === maxRetries - 1) throw error;
      await new Promise((resolve) =>
        setTimeout(resolve, 1000 * Math.pow(2, i))
      );
    }
  }
}

// Caching pattern for expensive operations
async function withCache<T>(
  key: string,
  operation: () => Promise<T>,
  ttl: number = 300000
): Promise<T> {
  const cached = await context.cache.get(key);
  if (cached) return cached;

  const result = await operation();
  await context.cache.set(key, result, ttl);
  return result;
}