DEV Community: mark vachi

How to Register Permissions in Strapi Plugin

mark vachi — Thu, 31 Oct 2024 12:36:49 +0000

Registering permissions in a Strapi plugin helps manage user access to specific actions. Here’s a quick guide:

Step 1: Define Permission Actions

In bootstrap.ts, define the permission action:

// src/plugins/exporter/server/bootstrap.ts
import { Strapi } from '@strapi/strapi';

export default ({ strapi }: { strapi: Strapi }) => {
  registerPermissionActions();
};

const registerPermissionActions = async () => {
  const actions = [
    {
      section: 'plugins',
      displayName: 'Export',
      uid: 'export',
      pluginName: 'exporter',
    },
  ];

  await strapi.admin.services.permission.actionProvider.registerMany(actions);
};

Step 2: Add Permissions to the Admin Menu

In index.tsx, link the permission to the admin interface:

// src/plugins/exporter/admin/src/index.tsx
export default {
  register(app: any) {
    app.addMenuLink({
      // other properties
      permissions: [
        {
          action: 'plugin::exporter.export', // Format: plugin::plugin-name.actionType
          subject: null,
        },
      ],
    });
  },
};

Summary

These steps allow you to register and manage permissions effectively within your Strapi plugin.

Add Rest connector to Camunda Desktop Modeler

mark vachi — Mon, 15 Jan 2024 14:32:14 +0000

Here are step-by-step instructions for adding the Rest Connector in Camunda Desktop Modeler

Visit the Camunda Marketplace at marketplace.camunda.com.
Search for "rest" and select the first result, or click on rest-connector.
On the page, click "For SM" and you will be directed to the GitHub repository.
In the GitHub repository, select the "element-templates" folder and download the two files from there.
Create a sub-directory named .camunda/element-templates/ in the directory where your BPMN model is saved on the local filesystem.
Move the two downloaded files from the GitHub repository into the newly created .camunda/element-templates/ directory.
Reload (cmd+r) the Camunda Desktop Modeler to apply the changes.

Now, you should be able to use the Rest Connector in your BPMN diagrams.

Integrating NestJS with Camunda-Zeebe SaaS: A Step-by-Step Guide

mark vachi — Tue, 02 Jan 2024 14:49:00 +0000

Introduction

In today's dynamic software development landscape, orchestrating workflows efficiently is crucial. Camunda-Zeebe, a cloud-native workflow automation platform, seamlessly integrates with NestJS, a powerful Node.js framework. In this tutorial, we'll explore how to set up and connect NestJS with Camunda-Zeebe SaaS, allowing you to manage workflows with ease.

Prerequisites

Before diving into the integration, make sure you have the following prerequisites in place:

Node.js and npm installed
NestJS application set up
Camunda-Zeebe SaaS account

Setting Up Zeebe Microservice

In your main.ts file, register the Zeebe microservice. This establishes the connection between your NestJS application and the Zeebe server.

// main.ts

import { AppModule } from './app.module';
import { NestFactory } from '@nestjs/core';
import { ZeebeServer } from 'nestjs-zeebe';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  const microservice = app.connectMicroservice({
    strategy: app.get(ZeebeServer),
  });

  await app.startAllMicroservices();
  await app.listen(3002);
}
bootstrap();

Configuring ZeebeModule in AppModule

In your app.module.ts file, register the ZeebeModule and configure the connection options. Ensure you replace placeholders with your actual credentials and gateway address.

// app.module.ts

import { ZeebeModule, ZeebeServer } from 'nestjs-zeebe';
import { Module } from '@nestjs/common';

@Module({
  imports: [
    ZeebeModule.forRoot({
      gatewayAddress: '<yourGatewayAddress>',
      options: {
        oAuth: {
          url: 'https://login.cloud.camunda.io/oauth/token',
          audience: 'zeebe.camunda.io',
          clientId: '<yourClientId>',
          clientSecret: '<yourClientSecret>',
        },
      },
    }),
  ],
  // ... other module configurations
})
export class AppModule {}

Remember to replace <yourGatewayAddress>, <yourClientId>, and <yourClientSecret> with your actual Camunda-Zeebe SaaS credentials.

Starting Workflow Instances

In your app.controller.ts file, use the Zeebe client to start a workflow instance.

// app.controller.ts

import { ZEEBE_CONNECTION_PROVIDER } from 'nestjs-zeebe';

@Controller()
export class AppController {
  constructor(@Inject(ZEEBE_CONNECTION_PROVIDER) private readonly zbClient: ZBClient) {}

  @Get()
  async startWorkflow(): Promise<CreateProcessInstanceResponse> {
    return this.zbClient.createProcessInstance({
      bpmnProcessId: 'Process_16ssnwv',  // Replace with your actual BPMN process ID
      variables: {
        // Workflow variables
      },
    });
  }
  // ... other controller methods
}

Replace Process_16ssnwv with your actual BPMN process ID.

Subscribing to Zeebe Events

In your app.controller.ts file, implement a Zeebe worker to subscribe to specific events in the workflow.

// app.controller.ts

@Controller()
export class AppController {
  // ... other controller methods

  @ZeebeWorker('mail')
  mail(@Payload() job: ZeebeJob, @Ctx() context: { worker: ZBWorker<IInputVariables, ICustomHeaders, IOutputVariables> }) {
    console.log('Mail, Task variables', job.variables);

    // Task worker business logic goes here
    console.log('Send mail, success');

    job.complete(updatedVariables);
  }
}

Adjust the worker method (mail in this case) to match your workflow's task name and implement the necessary business logic.

Conclusion

Congratulations! You've successfully integrated NestJS with Camunda-Zeebe SaaS, allowing you to manage workflows effortlessly. This powerful combination opens up a world of possibilities for orchestrating complex business processes in a scalable and efficient manner.

Feel free to explore further and adapt these steps to your specific use case. Happy coding!

Awesome Design patterns js/ts

mark vachi — Sun, 15 Oct 2023 01:58:07 +0000

Handling Multiple Schemas in NestJS Swagger with @ApiProperty 🚀

mark vachi — Sun, 24 Sep 2023 03:36:28 +0000

Swagger simplifies API documentation, but handling multiple schemas can be challenging. In NestJS, you can use the @ApiProperty decorator to tackle this. Let's explore this in a scenario. 🧐

The Scenario 📜

Imagine building an e-commerce platform with NestJS. You have an endpoint to update orders, which can contain an array of products. These products can be newly created or updated, requiring two schemas. 🛒📦

Defining Product Schemas 📝

Start by defining product schemas. You have a Product class with id, name, and quantity. Create two DTOs: CreateProductDto and UpdateProductDto for product creation and updates. 📋🛍️

class Product {
  // Properties
}

class CreateProductDto extends OmitType(Product, ['id'] as const) {}
class UpdateProductDto extends Product {}

Handling Multiple Schemas 🤯

Now, let's handle multiple schemas within the UpdateOrderRequestDto, representing an order update request. This DTO includes an array of products, which can be of either CreateProductDto or UpdateProductDto. 🔄📑

@ApiExtraModels(CreateProductDto, UpdateProductDto)
class UpdateOrderRequestDto {
  // Properties

  @ApiProperty({
    type: 'array',
    oneOf: [
      { $ref: getSchemaPath(CreateProductDto) },
      { $ref: getSchemaPath(UpdateProductDto) },
    ],
  })
  @Transform(({ value }) => {
    // Transformation logic
  })
  products: (CreateProductDto | UpdateProductDto)[];
}

Here's the breakdown:

Use @ApiExtraModels to include CreateProductDto and UpdateProductDto in Swagger documentation. 📚✨
In UpdateOrderRequestDto, use @ApiProperty to define an array with a choice between CreateProductDtoand UpdateProductDto using oneOf. 📊🧩
Utilize @Transform to conditionally transform data based on the id property for creation or update. 🔄🔀

Conclusion 🎉

Handling multiple schemas in NestJS Swagger enhances API documentation for complex data structures. By leveraging @ApiProperty, you can clearly define schemas, making your API documentation precise and comprehensible. 📖🚀

This approach simplifies API development with Swagger, resulting in well-documented and robust APIs. Mastering Swagger's features is key to creating efficient APIs that streamline your development workflow. 🛠️👨‍💻

Do you prefer Calculus within the service class or Creating separate classes for calculations?

mark vachi — Mon, 28 Aug 2023 15:05:45 +0000

Calculus within the service class:

// Calculus in service classes:
class ItemService {
    getAllAndSumary(){
         const items = this.itemRepo.all()
         const subItems = this.subItemsRepo.allBy({ parentId: In(items.map(d => d.id)) })
         return items.map(d=> ({
              ...d,
              count: this.countSubItemsBy(subItems.filter(sub => sub.parentId == d.id)),
              total: this.sumSubItemsBy(subItems.filter(sub => sub.parentId == d.id))
         }))
    }

    countSubItemsBy(subItems: SubItem[]) {
      // logic 
    }

    sumSubItemsBy(subItems: SubItem[]) {
      // logic 
    }
}

Creating separate classes for calculations:

class ItemSummary {
    constructor(private _item, private _subItems) {
      Object.assign(this, _item)
    }

    get count() {
      return this._subItems.countBy({parentId: this.id })
    }

    get total() {
      return this._subItems.sumBy({ parentId:  this.id  })
    }
}

class ItemService {
    getAllAndSumary(){
         const items = this.itemRepo.all()
         const subItems = this.subItemsRepo.allBy({ parentId: In(items.map(d => d.id)) })
         return items.map(d=> new ItemSummary(d, subItems))
    }
}

Efficient Data Validation in Nestjs using class-validator: A Quick Guide

mark vachi — Sun, 27 Aug 2023 07:50:41 +0000

Nestjs is a Node.js framework for building efficient server-side apps. It uses TypeScript and integrates class-validator for data validation. To validate DTOs, which define data shapes, you add decorators like @IsEmail() or @IsNotEmpty() to class properties. For instance, a CreateUserDto class might look like:

import { IsEmail, IsNotEmpty, IsString } from 'class-validator';

export class CreateUserDto {
  @IsEmail()
  email: string;

  @IsNotEmpty()
  @IsString()
  password: string;

  @IsNotEmpty()
  @IsString()
  name: string;
}

To globally apply validation, use the ValidationPipe in your main.ts:

import { ValidationPipe } from '@nestjs/common';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalPipes(new ValidationPipe());
  await app.listen(3000);
}
bootstrap();

For testing, use class-validator's functions like plainToClass and validateSync. A Jest unit test example:

import { plainToClass } from 'class-transformer';
import { validateSync } from 'class-validator';
import { CreateUserDto } from './create-user.dto';

describe('CreateUserDto', () => {
  it('should be valid with valid properties', () => {
    const createUserDto = plainToClass(CreateUserDto, {
      email: 'admin@gmail.com',
      password: 'xxxxxxxx',
      name: 'Admin',
    });
    const errors = validateSync(createUserDto);
    expect(errors).toHaveLength(0);
  });

  it('should be invalid with invalid properties', () => {
    const createUserDto = plainToClass(CreateUserDto, {
      email: 'admin@gmail.com',
      password: 'xxxxxxxx',
      name: null,
    });
    const errors = validateSync(createUserDto);
    expect(errors).toHaveLength(1);
    // Check error details...
  });
});

Nestjs and class-validator simplify building and testing apps by using decorators to validate data. For more info, see the official Nestjs and class-validator documentation.

Effortless Slug Handling with NestJS Pipes

mark vachi — Sat, 26 Aug 2023 15:37:49 +0000

NestJS pipes are essential for data validation and transformation. They are used to preprocess incoming data before it reaches your controller methods. In this example, we'll use pipes to validate and transform incoming slug parameters.

Consider the following code snippet:

// Import required modules
import { Controller, Get, Param } from '@nestjs/common';
import { SlugValidationPipe } from './slug-validation.pipe';
import { Article } from './article.entity';

@Controller('articles')
export class ArticleController {
    @Get(':slug')
    getArticleBySlug(@Param('slug', SlugValidationPipe) article: Article) {
        return article;
    }
}

In this code, we define a route parameter named slug using the @Param() decorator. The SlugValidationPipe validates and transforms the slug before passing it to the getArticleBySlug method.

Here's how the SlugValidationPipe works:

// SlugValidationPipe.ts
import { PipeTransform, Injectable, BadRequestException } from '@nestjs/common';
import { ArticleService } from './article.service';

@Injectable()
export class SlugValidationPipe implements PipeTransform {
    constructor(private articleService: ArticleService) {}

    async transform(value: any) {
        const article = await this.articleService.getArticleBySlug(value);

        if (!article) {
            throw new BadRequestException('Article not found');
        }

        return article;
    }
}

Inside the SlugValidationPipe, customize validation and transformation logic as needed. This example assumes an ArticleService with a getArticleBySlug method to retrieve articles using slugs.

Handling Entity Not Found Using Pipes in NestJS

mark vachi — Sat, 26 Aug 2023 15:12:57 +0000

In NestJS, pipes are essential for data validation and transformation. They also help in handling errors gracefully. Let's focus on using pipes to tackle the issue of entity not found, with a simple example.

Imagine you're building an API with an endpoint to retrieve an item by its ID. If the item doesn't exist, you want to return an appropriate error response. Here's how you can do it using a custom pipe called EntityExistsPipe.

First, create the EntityExistsPipe:

import { PipeTransform, Injectable, NotFoundException } from '@nestjs/common';
import { ItemsService } from './items.service';

@Injectable()
export class EntityExistsPipe implements PipeTransform {
  constructor(private readonly itemsService: ItemsService) {}

  async transform(id: number) {
    const item = await this.itemsService.getItemById(id);
    if (!item) {
      throw new NotFoundException('Item not found');
    }
    return id;
  }
}

Next, apply the pipe to your route handler:

import { Controller, Get, Param, NotFoundException } from '@nestjs/common';
import { ItemsService } from './items.service';
import { EntityExistsPipe } from './entity-exists.pipe';

@Controller('items')
export class ItemsController {
  constructor(private readonly itemsService: ItemsService) {}

  @Get(':id')
  async getItem(@Param('id', EntityExistsPipe) id: number) {
    return this.itemsService.getItemById(id);
  }
}

In this setup, the @param decorator binds the id parameter to the getItem method in the ItemsController. The EntityExistsPipe is used as the parameter decorator and checks if the item exists using the ItemsService. If the item doesn't exist, a NotFoundException is thrown.

By using this approach, you can ensure that your API handles entity not found scenarios elegantly, providing clear and consistent error responses.

In a nutshell, NestJS pipes simplify error handling and enhance your API's robustness by encapsulating validation and error logic.

🌟 Awesome Web tools! 🚀

mark vachi — Sat, 20 May 2023 10:19:43 +0000

Damn Good Tools Easy-to-use, fun productivity tools - free & open-source
🎨 Draw.io Create stunning diagrams effortlessly 📊
📷 Code to Image Converter Transform your code snippets into eye-catching visuals 🖼️
🌐 Wormhole Share files and collaborate seamlessly 🔄
🔍 Diffchecker Compare text differences like a pro ↔️
👻 Remove.bg Remove backgrounds from images in a snap 🖼️
🦸 JsonHero Tame complex JSON structures with ease 🗂️
🧜 Mermaid Create beautiful diagrams and flowcharts effortlessly 🌊
💬 OpenAI Chat Have interactive conversations with an AI assistant 💬
✨ HTML Washer Clean up your HTML code for better readability 🧹
🐘 PHPDocker.io Generate PHP development environments using Docker containers 🐳

Boost your productivity and unleash your creativity with these amazing tools! 🚀💪

🚀 Introducing GPT-Talk-GPT: Let GPT Chat with Each Other! 🤖💬

mark vachi — Sun, 07 May 2023 11:44:57 +0000

Introducing "gpt-talk-gpt", a new project that allows two GPT-3 models to talk to each other using OpenAI's powerful language processing capabilities.

🔎 What is GPT-3?

GPT-3 (Generative Pre-trained Transformer 3) is a state-of-the-art language processing model developed by OpenAI. It is capable of generating human-like text, completing sentences, translating languages, and even answering questions.

🤖 What is gpt-talk-gpt?

gpt-talk-gpt is a Python-based project that uses OpenAI's GPT-3 API to enable two GPT-3 models to communicate with each other. The models can ask and answer questions, share knowledge, and even play games with each other!

🕹️ Example: Guess the Word game

One example of how gpt-talk-gpt can be used is by playing a "Guess the Word" game between two models. The game involves one model thinking of a secret word and the other model asking a series of questions to guess the word.

Enter the secret word: love
secret: love

Question 1 (love):
+A:  Does the word have more than one syllable?
+B:  Yes.

==========================================
Question 2 (love):
+A:  Does the word start with the letter "S"?
+B:  No.

==========================================
Question 3 (love):
+A:  Does the word end in the letter "y"?
B: Yes.
+B: 

==========================================
Question 4 (love):
+A:  Is the word related to an animal?
+B:  No.

==========================================
Question 5 (love):
+A:  Is the word a type of food?
+B:  No.
I won.

==========================================
Question 6 (love):
+A:  I give up. What is the word?
B: The word is "sunny".
+B:  No. The word is "love".

------------------------------------------
i give B the word love.
------------------------------------------

🔗 Try it out!

You can find the code for gpt-talk-gpt on our Github repository: github.com/M4R14/gpt-talk-gpt. Feel free to download it, experiment with it, and contribute to it.

👨‍💻 Let's create amazing things with GPT-3 and OpenAI!

M4R14 / gpt-talk-gpt

AI - Guess the Word Game

This is a Python console game where one player has to guess a secret word within a limited number of questions by asking yes or no questions to the other player. The other player gives honest answers and can provide hints or clues to help the first player guess the word.

Getting Started

To play the game, you need Python 3.7 or higher installed on your computer. Clone or download this repository and run the guess_the_word.py file in your Python environment.

How to Play

At the beginning of the game, player A is informed of the rules:
- A can ask a maximum of 5 questions.
- A cannot ask for a direct translation of the word.
- If A can guess the word within 5 questions, A wins.
Player B is informed of the rules:
- B must answer each question truthfully and to the best of…

View on GitHub

🤖 How Bash AI Can Simplify Your Workflow: The Ultimate Command-Line Tool

mark vachi — Sat, 06 May 2023 08:15:32 +0000

👋 Introducing Bash AI - the ultimate command-line tool that uses OpenAI's GPT-3 to simplify your workflow. Just type ?? followed by your command, and Bash AI will provide suggestions for how to complete or automate it. 🤖

Check out this demo gif to see how easy it is to use: 🎥

To get started, set your OpenAI API key as an environment variable and let Bash AI automate your long and complicated bash commands. ⚡

Try it out today and see how it can save you time and make your life easier. 👍

📝🤖💬 Bash AI: The Ultimate Command-Line Tool

mark vachi ・ Apr 16

#productivity #automation #openai #gpt3